Scalable database system for querying time-series data

ABSTRACT

A database system stores data as hypertables that represent partitioned database tables. Each hypertable comprises chunks of data that may be distributed across multiple locations, each location comprising at least a storage device. The database system provides an interface that allows database queries seamlessly to hypertables as well as standard tables. The database system dynamically creates chunks as records are added to a hypertable. The database system defines a new partitioning strategy if the storage configuration of the database system is changed by adding new locations or removing existing locations. The records added to the hypertable before the storage configuration was changed continue to be stored as chunks distributed according to the previous partitioning policy.

CROSS-REFERENCE TO RELATED APPLICATION

This application claims the benefit of U.S. Provisional Application No.62/464,289, filed on Feb. 27, 2017, which is incorporated by referencein its entirety.

BACKGROUND

This disclosure relates generally to efficiently storing and processingdata in a database system, and in particular to storing and processingtime series data in a partitioned database system.

Time-series data is generated and processed in several contexts:monitoring and developer operations (DevOps), sensor data and theInternet of Things (IoT), computer and hardware monitoring, fitness andhealth monitoring, environmental and farming data, manufacturing andindustrial control system data, financial data, logistics data,application usage data, and so on. Often this data is high in volume,for example, individual data sources may generate high rates of data, ormany different sources may contribute data. Furthermore, this data iscomplex in nature, for example, a source may provide multiplemeasurements and labels associated with a single time. The volume ofthis stored data often increases over time as data is continuallycollected. Analytical systems typically query this data to analyze thepast, present, and future behavior of entities associated with the data.This analysis may be performed for varied reasons, including examininghistorical trends, monitoring current performance, identifying the rootcause of current problems, and anticipating future problems such as forpredictive maintenance. As a result, operators are not inclined todelete this potentially valuable data.

Conventional systems fail to support the high write rates that aretypical of many of these applications, which span across industries. Forexample, in Internet of Things (IoT) settings including industrial,agricultural, consumer, urban, or facilities, high write rates resultfrom large numbers of devices coupled with modest to high write ratesper device. In logistics settings, both planning data and actualscomprise time series that can be associated with each tracked object.Monitoring applications, such as in development and operations, maytrack many metrics per system component. Many forms of financialapplications, such as those based on stock or option market ticker data,also rely on time-series data. All these applications require a databasethat can scale to a high ingest rate.

Further, these applications often query their data in complex andarbitrary ways, beyond simply fetching or aggregating a single metricacross a particular time period. Such query patterns may involve richpredicates (e.g., complex conjunctions in a WHERE clause), aggregations,statistical functions, windowed operations, JOINs against relationaldata, subqueries, common table expressions (CTEs), and so forth. Yetthese queries need to be executed efficiently.

Therefore, storing time-series data demands both scale and efficientcomplex queries. Conventional techniques fail to achieve both of theseproperties in a single system. Users have typically been faced with thetrade-off between the horizontal scalability of “NoSQL” databases versusthe query power of relational database management systems (RDBMS).Existing solutions for time-series data require users to choose betweeneither scalability or rich query support.

Traditional relational database systems that support database querylanguages such as SQL (structured query language) have difficultyhandling high ingest rates: They have poor write performance for largetables, and this problem only becomes worse over time as data volumegrows linearly in time. Further, any data deletion requires expensive“vacuuming” operations to defragment the disk storage associated withsuch tables. Also, out-of-the-box open-source solutions for scaling-outRDBMS across many servers are still lacking.

Existing NoSQL databases are typically key-value or column-orienteddatabases. These databases often lack a rich query language or secondaryindex support, however, and suffer high latency on complex queries.Further, they often lack the ability to join data between multipletables, and lack the reliability, tooling, and ecosystem of morewidely-used traditional RDBMS systems.

Distributed block or file systems avoid the need to predefine datamodels or schemas, and easily scale by adding more servers. However,they pay the cost for their use of simple storage models at query time,lacking the highly structured indexes needed for fast andresource-efficient queries.

Conventional techniques that also fail to support an existing,widely-used query language such as SQL and instead create a new querylanguage, require both new training by developers and analysts, as wellas new customer interfaces or connectors to integrate with othersystems.

SUMMARY

The above and other issues are addressed by a computer-implementedmethod, computer system, and computer readable storage medium fordynamically creating chunks for storing records being added to ahypertable representing a partitioned database table. Embodiments of themethod comprise receiving an insert request by a database system andprocessing the insert request. The insert request identifies ahypertable and one or more input records for inserting in thehypertable. Each record has a plurality of attributes including a set ofdimension attributes that include a time attribute. The hypertable ispartitioned into a plurality of chunks based on the dimensionattributes. A chunk is specified using a set of values for eachdimension attribute. For each record stored in the chunk, the value ofeach dimension attribute maps to a value from the set of values for thatdimension attribute. A determination is made whether an input recordshould be stored in a new chunk or an existing chunk. For each new chunkbeing created, sets of values corresponding to each dimension attributeare determined and the new chunk is created for storing the inputrecord. The hypertable is updated by storing the input record in the newchunk. The data stored in the updated hypertable is processed inresponse to subsequent queries that identify the hypertable.

Embodiments of a computer readable storage medium store instructions forperforming the steps of the above method. Embodiments of a computersystem comprise one or more computer processors and a computer readablestorage medium storing instructions for performing the steps of theabove method.

The features and advantages described in this summary and the followingdetailed description are not all-inclusive. Many additional features andadvantages will be apparent to one of ordinary skill in the art in viewof the drawings, specification, and claims hereof.

BRIEF DESCRIPTION OF THE DRAWINGS

The teachings of the embodiments can be readily understood byconsidering the following detailed description in conjunction with theaccompanying drawings.

FIG. 1 is a block diagram of a system environment in which the databasesystem operates, in accordance with an embodiment.

FIG. 2 illustrates partitioning of data of a database table, inaccordance with an embodiment.

FIG. 3 shows processing of queries in a database system comprising aplurality of database nodes, in accordance with an embodiment.

FIG. 4A shows the system architecture of a query processor, inaccordance with an embodiment.

FIG. 4B shows the system architecture of a chunk management module, inaccordance with an embodiment.

FIG. 5 illustrates the process of inserting records into a hypertablestored across a plurality of database system nodes, in accordance withan embodiment.

FIG. 6 is a flowchart of the process of executing a query for processingrecords stored in a hypertable, in accordance with an embodiment.

FIGS. 7(A-C) illustrate partitioning of data of a database table toadapt to addition of locations to the database system according to anembodiment of the invention.

FIG. 8 shows a flowchart illustrating the process of modifying a datapartitioning policy of a database system in response to addition of newlocations to the database system, in accordance with an embodiment.

FIG. 9 illustrates selection of partitioning policy for creating chunksbased on time attribute of the record, according to an embodiment.

FIG. 10 shows a flowchart of the process for selection of partitioningpolicy for creating chunks based on time attribute of the record,according to an embodiment.

FIG. 11 illustrates selection of partitioning policy for creating chunksbased on time of receipt of a record by the database system, accordingto an embodiment.

FIG. 12 shows an architecture of a computer that may be used forimplementing a database system node, in accordance with an embodiment.

DETAILED DESCRIPTION

Embodiments of the invention include a database system that supports astandard query language like SQL and exposes an interface based on ahypertable that partitions the underlying data across servers and/orstorage devices. The database system allows users to interact with dataas if it were stored in a conventional database table, hiding thecomplexity of any data partitioning and query optimization from theuser. Embodiments of the database system make a query language like SQLscalable for time-series data. The database system combines the bestfeatures of both RDBMS and NoSQL databases: a clustered scale-up andscale-out architecture and rich support for complex queries. Scaling upcorresponds to running on larger individual servers, for example,machines with high numbers of CPUs or cores, or servers with greater RAMand disk capacity. Scaling up also includes increasing storage capacityof an existing database system by adding additional storage devices.Scaling out comprises increasing storage capacity of the database systemby adding additional servers, for example, by sharding the dataset overmultiple servers, as well as supporting parallel and/or concurrentrequests across the multiple servers.

System Environment

FIG. 1 is a block diagram of a system environment in which the databasesystem operates, in accordance with an embodiment. The systemenvironment comprises a database system 110, one or more client devices120, and a network 115.

The database system 110 comprises a query processor 130, a metadatastore 140, and a data store 145. The database system 110 may includeother components, for example, as illustrated in FIG. 2. The databasesystem 110 receives database queries, for example, queries specifiedusing SQL and processes them. The database system 110 may supportstandard SQL features as well as new user-defined functions, SQLextensions, or even non-SQL query languages such as declarativeprogramming languages, a REST interface (e.g., through HTTP), or others.

The data store 145 stores data as tuples (also referred to as records)that may be stored as rows of data, with each row comprising a set ofattributes. These attributes typically have a name associated with them(e.g., “time”, “device_id”, “location”, “temperature”, “error_code”) anda type (e.g., string, integer, float, boolean, array, json, jsonb(binary json), blob, geo-spatial, etc.), although this is not necessaryin all cases. Attributes may also be referred to herein using the terms“fields”, “columns” or “keys”.

The data store 145 may store records in a standard database table thatstores data in one or more files using conventional techniques used byrelational database systems. The data store 145 may also store data in apartitioned database table referred to as a hypertable. A hypertable isa partitioned database table that provides an interface of a singlecontinuous table—represented by a virtual view—such that a requestor canquery it via a database query language such as SQL. A hypertable may bedefined with a standard schema with attributes (or fields or column)names and types, with at least a time attribute specifying a time value.The hypertable is partitioned along a set of dimension attributesincluding the time attributes and zero or more other dimensionattributes (sometimes referred to as the hypertable's “space”attributes). These dimension attributes on which the hypertable ispartitioned are also referred to as “partitioning key(s)”, “partitionkey(s)”, or “partitioning fields.” A hypertable may be created using astandard SQL command for creating a database table. Furthermore, queriesto the hypertable may be made using database queries, for example, SQLqueries.

The database system splits the hypertable into chunks. Each chunk storesa subset of records of the hypertable. A chunk may also be referred toherein as a data chunk or a partition. The database system 110 maydistribute chunks of a hypertable across a set of one or more locations.A location may represent a storage medium for storing data or a systemthat comprises a storage medium for storing data, for example, a server.The storage medium may be a storage device, for example, a disk. Thedatabase system 110 may store data on multiple storage devices attachedto the same server or on multiple servers, each server attached with oneor more storage devices for storing chunks. A storage device may beattached to a remote server, for example, in a cloud-based system and aserver of the database system provided access to the remote storagedevice for storing chunks.

The database system can store multiple hypertables, each with differentschemas. Chunks within the same hypertable often have the same schema,but may also have different schemas. The database system may alsoinclude standard database tables, i.e., traditional non-partitionedtables stored in the same database. Operations are performed against anyof these tables, including multiple tables in a single query. Forexample, this can involve a SELECT that JOINS data between a hypertableand a standard non-partitioned table, or between two hypertables, or anymore complex combination thereof. Or, it may involve inserting data intoa hypertable and a standard non-partitioned table, or between twohypertables, or more complex combinations, as a single transaction.

In some embodiments, the database system 110 is comprised of one or moredatabase system nodes (also referred to as database servers or justservers) that are connected over a network. Each node may include thesame or similar components from FIG. 1, such as a query processor 130,metadata store 140, and data store 145. The details of a database systemnode are described in FIG. 2. The metadata store 140 stores metadatadescribing the data stored in the data store 145 including descriptionsof various hypertables and standard non-partitioned tables. Thedescription includes various attributes of each table, the descriptionof various chunks of a hypertable, and so on. The query processor 130receives and processes queries as further described herein.

The database system 110 may be connected to requesters issuing databasequeries to the database system 110. A requestor may be any source of thedatabase queries, for example, a client device 120, a webserver,application server, user workstation, or a server or machine that issending the query on behalf on another origin (e.g., an intermediateserver or middleware layer acting as a queue, buffer, or router such asfor INSERTS, or an application acting on behalf of another system oruser).

This connection from the requester often occurs over the network 115,although it can also be on the same server executing the databasesystem. For example, the network 115 enables communications between theclient device 120 or any other requestor and the database system 110. Inone embodiment, the network uses standard communications technologiesand/or protocols. The data exchanged over the network can be representedusing technologies and/or formats including the open databaseconnectivity (ODBC) format, the Java database connectivity (JDBC)format, the PostgreSQL foreign data wrapper (FDW) format, the PostgreSQLdblink format, the external data representation (XDR) format, the GoogleProtocol Buffer (protobuf) format, the Apache Avro format, the hypertextmarkup language (HTML), the extensible markup language (XML), Javascriptobject notation (JSON), etc.

The client device 120 can be a personal computer (PC), a desktopcomputer, a laptop computer, a notebook, a tablet PC executing anoperating system. In another embodiment, the client device 120 can beany device having computer functionality, such as a personal digitalassistant (PDA), mobile telephone, smartphone, wearable device, etc. Theclient device can also be a server or workstation, including running ina backoffice environment, within an enterprise datacenter, or within avirtualized cloud datacenter. The client device executes a clientapplication for interacting with the database system 110, for example, abrowser 125, a database shell, a web service application (such as .NET,Djagno, Ruby-on-Rails, Hibernate), a message broker (such as ApacheKafka or RabbitMQ), a visualization application, and so forth.

FIG. 1 and the other figures use like reference numerals to identifylike elements. A letter after a reference numeral, such as “120A,”indicates that the text refers specifically to the element having thatparticular reference numeral. A reference numeral in the text without afollowing letter, such as “120,” refers to any or all of the elements inthe figures bearing that reference numeral (e.g. “120” in the textrefers to reference numerals “120A” and/or “120N” in the figures).

FIG. 2 illustrates partitioning of data as chunks for a hypertable, inaccordance with an embodiment. Each of these chunks correspond to aportion of the entire dataset organized according to some partitioningfunction involving one or more of a record's attributes. The attributesof the record that are used for partitioning the hypertable as chunksare referred to as dimension attributes. Accordingly, a chunkcorresponds to an “n-dimensional” split of the hypertable (for n≥1).

The database system 110 may implement a chunk as a file. In oneembodiment, each chunk is implemented using a standard database tablethat is automatically placed on one of the locations (e.g., storagedevices) of one of the database nodes (or replicated between multiplelocations or nodes), although this detail may not be observable tousers. In other embodiments, the placement of chunks on locations and/ordatabase nodes is specified by commands or policies given by databaseadministrators or users.

One of the dimension attributes is a time attribute that storestime-related values. The time attribute can be any data that can becomparable (i.e., has a > and ≥ operator), such that data can be orderedaccording to this comparison function. Further, new records aretypically associated with a higher time attribute, such that this valueis commonly increasing for new records. Note that this value can bespecified in the data record, and need not (and often does not)correspond to when data is inserted into the database. The followingvalues may be used as a time attribute: datetime timestamps (includingwith or without timezone information), UNIX timestamps (in seconds,microseconds, nanoseconds, etc.), sequence numbers, and so on. In anembodiment, the hypertable is also split along a dimension attributethat represents a distinct identifier for objects or entities describedin the database table (e.g., a device id that identifies devices, aserver id that identifies servers, the ticker symbol of a financialsecurity, etc.).

A chunk is associated with a set of values corresponding to eachdimension attribute. For example, a hypertable may have two dimensionattributes d1 and d2. For a given chunk C1, the dimension attribute d1is associated with a set of values S1 and the dimension attribute d2 isassociated with a set of values S2. Accordingly, each record stored inthe chunk C1 has a dimension attribute value that maps to a value in theset of values corresponding to the dimension attribute. For example,assume that a hypertable includes attributes time, device, andtemperature. Also assume that time is a dimension attribute and a chunkis associated with a range of time [0:00:00-11:59:59.999]. If an inputrecord has values {time: “1:00:00”, device: “A”, temperature: 65}, thechunk may store the input record since the value of the time dimension“1:00:00” falls within the range associated with the chunk, i.e.,[0:00:00-11:59:59.999].

A set of values corresponding to a dimension attribute may represent arange of values but is not limited to ranges. For example, the set ofvalues may represent a plurality of ranges that are not contiguous.Alternatively, the set of values may be specified by enumerating one ormore values. For example, a dimension attribute c1 may represent colors(e.g., “red”, “blue”, “green”, “yellow”), and a chunk may store recordsthat have the value of dimension attribute c1 from the set {“red”,“blue”} and another chunk may store records that have the value ofdimension attribute c1 from the set {“green”, “yellow”}.

A given value of a dimension attribute may map to a value in the set ofvalues corresponding to that dimension if the given value is identicalto a value in the set of values. Alternatively, a given value v1 of adimension attribute may map to a value v2 in the set of valuescorresponding to that dimension if the value v2 is obtained by applyinga transformation (for example, a function) to the given value v1. Forexample, database system 110 may use a hash partitioning strategy wherethe set of values corresponding to a dimension is specified as arange/set of values obtained by applying a hash function to thedimension attribute values. Accordingly, if a dimension attribute valueis represented as vx, and H represents a hash function, a chunk Cx maybe associated with a range R=[x1, x2] (or set) of values for H(vx).Accordingly, the chunk may store a record with dimension attribute valuev1 if H(v1) lies in the range [x1, x2].

In an embodiment, the set of values may correspond to a plurality ofdimension attributes. For example, the hash function specified in theabove example may receive two or more inputs, each corresponding to adistinct dimension attribute, i.e., H(v1, v2, . . . ). Accordingly, adimension of a chunk may be defined as a composite attribute comprisinga plurality of dimension attributes of the hypertable.

FIG. 2 shows a hypertable 160 split into a plurality of chunks 210 alongtwo dimension attributes, a time attribute and another dimensionattribute referred to as the space attribute. In this example, eachchunk is associated with a time range comprising a start time and an endtime, and a space range comprising a contiguous range of alphabeticalcharacters. For example, chunk 210 a stores a set of records that havethe value of time attribute within the range [0, 6] and the value ofspace attribute within the range [A, I]. Similarly, chunk 210 b stores aset of records that have the value of time attribute within the range[0, 6] and the value of space attribute within the range [J, R], and soon.

Different types of queries can be made to a hypertable, including thosethat only read from the hypertable (e.g., database SELECT statements),as well as those that modify the hypertable (e.g., database INSERT,UPDATE, UPSERT, and DELETE statements). Writes are typically sent to thechunks comprised of the latest time interval (but do not need to be),while queries may slice across multiple dimension attributes, forexample, both time and space.

Although hypertables and chunks are referred to herein as tables, thisterm is not meant to be limiting, and a chunk could refer to a number ofstorage representations, including a traditional relational databasetable, a virtual database view, a materialized database view, a set ofstructured markup language (e.g., XML), a set of serialized structureddata (e.g., JSON, Google Protocol Buffers, Apache Avro, Apache Parquet),or flat files (e.g., with comma- or tab-separated values).

Distributed Execution of Queries

FIG. 3 shows processing of queries in a database system comprising aplurality of database nodes, in accordance with an embodiment. Adatabase system node 310 a receives database queries and may send one ormore queries to chunks (that may be implemented as physical tables ofthe data), which are stored on the coordinator database system node oron other database system nodes. A database system node does not issue aquery to a chunk if it determines that the chunk is not needed tosatisfy the query. This determination uses additional metadata about thechunk, which may be maintained separate from or along with each chunk'sdata. Each database system node can also maintain additional metadata toallow it to efficiently determine a chunk's time interval andpartitioning field's keyspace. The database system may maintain themetadata separate from or along with a chunk.

As shown in FIG. 3, the database system node 310 a receives a firstdatabase query 320. The database system node 310 a determines that thedata required for processing the received database query is on one ormore database system nodes 310 a, 310 b, and 310 c. The database systemnode 310 a further sends queries 325 a and 325 b for processing thefirst query to the database system nodes 310 b and 310 c, respectively.All three database system nodes 310 a, 310 b, and 310 c process theirrespective queries using one or more chunks of data stored on theirrespective nodes. In the example, illustrated in FIG. 3, if the databasesystem node 310 a determines that the data required for processing thefirst query is stored only on database system nodes 310 a and 310 b butnot on 310 c, the database system node 310 a sends a query forprocessing to 310 b but not to 310 c. In other embodiments of thesystem, the queries 325 a and 325 b sent to the other nodes 310 b and310 c are the same as the first query 320, and the queries or requestssent to the other nodes can be in a different query language, format, orcommunication protocol as the first query. In some embodiments of thesystem, the queries 325 a and 325 b maybe identical to each other, whilein others they are different. Further, in other embodiments, node 310 adoes not store chunks itself, but only processes the query 320 andissues the corresponding queries 325 to other database nodes.

The database system node 310 a that receives the database query maydetermine that the query to the hypertable does not involve a particularchunk's data—for example, because the query specified a time perioddifferent than that associated with the chunk, or if the query specifiesa dimension attribute (e.g., an IP address, device ID, or some locationname) that is associated with a different chunk. In this situation, thefirst database system node does not issue a query to this particularchunk (which may be located on itself or on a different node). Thisdetermination by both the first database system node and any otherdatabase system nodes may be performed by the query processor 130present on each database system node that processes queries.

Any database system node may receive a query from a requester and thequery processor 130 running on this database system node determines howto plan and execute the query across the entire cluster of one or morenodes. This database system node sends a query (a “subquery”) to zero ormore other nodes in the system. Subsequently, the database systemnode(s) that receive a subquery from the first database system nodeinclude a query processor 130 that determines how to plan and executethe query locally.

In an embodiment, this process is extended to additional levels ofsubqueries and involved planners. In an embodiment, the database systemperforms this partitioning in a recursive fashion. For example, thechunk that is being stored on one of the nodes could itself be furtherpartitioned in time and/or by an additional partitioning key (either thesame or different than the partitioning key at a higher level), whichitself could be distributed among the node (e.g., on different disks) oreven to other nodes. In such a scenario, a chunk can act as anotherhypertable.

In some embodiment, the database system performs the query processingusing only the query processor 130 on the first database system node.Accordingly, the complete query plan is generated by the first node andsent to nodes that are determined to store chunks processed by thequery. The remaining nodes that receive the query plan (or some portionthereof) simply execute the received query plan without having togenerate a portion of the query plan. In other embodiments, the databasesystem implements less homogenous functionality across nodes, such thata first set of one or more nodes receives queries and plans and executesthe queries against a second disparate set of one or more nodes thatstore the chunks.

System Architecture

FIG. 4A shows the system architecture of a query processor, inaccordance with an embodiment. The query processor 130 comprisescomponents including a connector 410, a query parser 415, a queryplanner 425, a query optimizer 430, an execution engine 435, and a queryplan store 455. A query processor 130 receives a query in some querylanguage, such as SQL, which specifies the tables or datasets on whichthe query will apply (i.e., read or write data). A query or databasequery may represent a request to read data (e.g., SELECT statements inSQL) or modify data (e.g., INSERT, UPDATE, and DELETE statements in SQL)from the database.

The query parser receives this request and translates it to a queryrepresentation that is easier to process. For example, the query parser415 may generate a data structure representing the query that providesaccess to the information specified in the query. The query optimizer430 performs transformation of the query, for example, by rewritingportions of the query to improve the execution of the query. The queryplanner takes this machine-readable representation of the query, whichis typically declarative in nature, and generates a plan specifying howthe query should be executed against the stored data, which may bestored in memory (e.g., RAM, PCM) and/or on some type of non-volatilestorage media (e.g., flash SSD, HDD). The query processor 130 stores thegenerated plan in the query plan store 455. The execution engine 435executes the query against the stored data, and returns the results tothe requester. The connector 410 allows the query processor 130 toconnect to remote systems, for example, to access data stored in remotesystems.

FIG. 4B shows the system architecture of a chunk management module, inaccordance with an embodiment. The chunk management module 170 furthercomprises a chunk selection module 445, and a chunk creation module 450.The chunk selection module 445 implements a chunk selection functionthat determines a chunk for storing a given record. The chunk selectionmodule 445 determines whether an existing chunk can be used for storingthe record. If the chunk selection module 445 determines that none ofthe existing chunks can be used for storing the record, the chunkselection module 445 determines that a new chunk needs to be created andinvokes the chunk creation module 450 for creating the chunk. If thechunk selection module 445 determines that a new chunk needs to becreated, the chunk selection module 445 determines various parametersdescribing the new chunk. For example, the chunk creation module 450determines the sets of values corresponding to different dimensionattributes of the records that define the chunk boundaries. Accordingly,records stored in the chunk have dimension attribute values such thateach dimension attribute has a value that maps to a value in the set ofvalues corresponding to the chunk's dimension. For example, if a chunkhas two dimension attributes, based on time and a device id, then eachrecord stored in the chunk has a time attribute that falls within thechunks time range and a device id from the set of device ids associatedwith the chunk. The chunk creation module 450 determines a location forcreating the chunk and creates the chunk on the location.

The database system 110 stores in the metadata store 140, metadata 155describing the chunk. The metadata for a chunk includes informationassociating the chunk with the hypertable. Other type of metadatadescribing the chunk includes a name of the chunk, the various sets ofvalues of the dimension attributes (for example, time ranges for thetime attribute, and so on), information describing constraints andindexes for the chunk, and so on. The database system 110 may storeother metadata associated with the chunk, e.g., access statistics anddata distribution statistics to aid query planning.

A hypertable may be associated with certain policy configurations, forexample, indexes, constraints, storage parameters (e.g., fillfactorsettings, parallel worker settings, autovacuum settings, etc.), foreignkey relationships, and so on. In an embodiment, each chunk of thehypertable implements the policy configurations of the hypertablecontaining the chunk. Accordingly, when creating a chunk, the chunkcreation module 450 may also create structures such as indexes for thechunk and update metadata to specify constraints, foreign keyrelationships, and any other policy configurations for the chunk.Examples of constraints defined for a chunk include UNIQUE, NOT NULL,CHECK CONSTRAINT (i.e., timestamp between range), FOREIGN KEY, andEXCLUSION constraints. The chunk management module 170 continues tomanage the chunk once it is created, for example, by reindexing oldchunks periodically, moving old chunks to slower storage devices overtime, adding secondary constraints through dynamic inspection, and soon.

In an embodiment, the chunk management module 170 monitors the sizes ofthe chunks that were recently created. A recently created chunk (or arecent chunk) refers to a chunk that was created within a threshold timeinterval of the current time. The size of the threshold time intervalmay be configurable. The size represents the amount of data that isstored in the chunk, for example, the chunk's size of bytes, its numberof rows, and so on. The chunk management module 170 adjusts sets ofvalues of the dimension attributes for new chunks being created based onthe size of the recently created chunks. Accordingly, if the chunkmanagement module 170 determines that one or more recently createdchunks store data that exceeds certain high threshold values, the chunkmanagement module 170 adjusts the sets of values of one or moredimensions so that they have fewer elements than the corresponding setsof values of the recently created chunks. For example, if the chunkmanagement module 170 determines that the recently created chunks had arange of 12 hours for the time attribute, the chunk management module170 may decrease the range of time attributes of new chunks beingcreated to be 10 hours. Alternatively, if the chunk management module170 determines that one or more recently created chunks store data thatis below certain low threshold values, the chunk management module 170adjusts the sets of values of one or more dimensions so that they havemore elements than the corresponding sets of values of the recentlycreated chunks that were below the low size thresholds. For example, ifthe chunk management module 170 determines that the recently createdchunks had a range of 12 hours for the time attribute and stored veryfew records, the chunk management module 170 may increase the range oftime attributes of new chunks being created to be 15 hours.

In an embodiment, the chunk management module 170 monitors one or moreperformance metrics for the chunks that were recently created. The chunkmanagement module 170 adjusts the sets of values of dimension attributesfor new chunks being created based on the performance metrics for thechunks that were recently created. For example, the chunk managementmodule 170 may monitor insert rate and query execution time. Forexample, if the chunk management module 170 determines that for thecurrent sizes of chunks the insert rate of records has fallensignificantly (e.g., since the database system has started swapping todisk), then the chunk management module 170 determines the sets ofvalues of dimension attributes of new chunks being created such that thenew chunks are smaller.

In an embodiment, chunk management module 170 keeps statisticsdescribing chunks processed by each distinct query, for example, thenumber of chunks processed by each query. The chunk management module170 uses this statistical information to determine sets of values fordimension attributes of new chunks being created so as to improveperformance. In an embodiment, the chunk management module 170 monitorsthe dimension attribute boundaries specified in queries. If the chunkmanagement module 170 determines that commonly received queries havecertain pattern of boundaries, for example, a pattern of time alignment(e.g., typical queries request data for a day between midnight andmidnight), then the chunk management module 170 aligns newly createdchunks to match these boundaries. As another example, if the currentchunks have one hour time attribute ranges and the chunk managementmodule 170 determines that the queries are typically accessing data atan interval of a size of a full day, the chunk management module 170increases the chunk sizes to reach a size more aligned with the accesspatterns, yet one that still retains a high insert rate. For example,the chunk management module 170 may increase the time attribute range tobe 12 hours, e.g., if 12 hours gives a higher insert rate compared to a24-hour range.

In an embodiment, the chunk management module 170 determines the sets ofvalues of the dimension attributes of chunks being created based onranges of dimension attributes specifies in queries received by thedatabase system. For example, if the chunk management module 170 iscreating chunks with time attribute ranges from 11 pm to 11 pm, and thechunk management module 170 determines that the queries received areaccessing data from midnight to midnight, the chunk management module170 shifts the time range of the chunks being created to match the timeranges of the queries. This improves the performance of queries byavoiding the need to unnecessarily scan two chunks rather than one.

In an embodiment, the chunk management module 170 distributes chunksacross a plurality of locations based on the properties of the storagemedia of each location. The chunk management module 170 identifies thestorage medium for storing the new chunk and accesses properties of thestorage medium, for example, properties describing a rate of access ofdata stored on the storage medium. The chunk management module 170determines a number of chunks from the plurality of chunks beingassigned to a location based on the properties of the storage mediumcorresponding to that location. For example, the chunk management module170 accesses metrics describing the rate at which a storage mediumaccesses random data. Certain storage mediums, e.g., solid-state drives(SSDs) and random-access memory (RAM), can handle random reads muchbetter than spinning hard disk drives (HDDs). Accordingly, the chunkmanagement module 170 assigns more chunks from the plurality of chunksto a location having a storage medium with faster access time for randomaccesses.

In one embodiment, the chunk creation module 450 creates a new chunk—and“closes” an existing one—when the existing chunk approaches or exceedssome threshold size (e.g., in bytes on disk or in memory, in its numberof rows, etc.). Each chunk is represented by a start and end time(defining its interval). With a purely size-based approach, however, thedatabase system would not know a priori the end time of a newly-createdchunk. Thus, when a chunk is first created, the chunk's end time isunset; any row having time greater than (or equal to) the start time isassociated with the chunk. However, when a chunk's size approaches orexceeds some threshold, the query planner 425 closes the chunk byspecifying its end time, and the chunk creation module 450 creates a newchunk. This new chunk starts at the time the old chunk ends. With thisapproach, the chunk has an indeterminate end time for a chunk until itis closed. A similar logic is applied to an indeterminate start-time. Itis also possible for an initial chunk to have both an indeterminatestart and end time. An embodiment of the database system performs thisdetermination and chunk creation asynchronously or in the background,while another performs these actions during the process of inserting a(set of) row(s) from the received batch to the chunk. The creation ofthe new chunk at insert time can happen in a variety of ways: beforeinserting the rows (the query planner 425 decides that the existingchunk is too full already, and creates a new chunk to insert into);after inserting the rows into the chunk; or in the middle of insertingthe rows (e.g., the query planner 425 decides the chunk only has spacefor a subset of the rows, so the subset is inserted into the currentchunk and the remainder of the set is inserted into a newly createdchunk).

In other embodiments, the database system defines a chunk as having aparticular time interval (that is, both a start and end time) when thechunk is created. Then the system creates a new chunk when needed, e.g.,when new data is to be inserted to a time interval that does not yetexist. In one embodiment, the database system also employs a maximumsize even with this approach, so that, for example, a second chunk iscreated with the same time interval as the first chunk if the size isapproached or exceeded on the first chunk, and the query planner 425writes new data to only one of the chunks. Once a second chunk iscreated, the database system may rebalance data from the first to secondchunk. In another embodiment, rather than overlap the time intervals ofthe first and second chunk, the first chunk's end time is modified whenthe second chunk is created so that they remain disjoint and their timeintervals can be strictly ordered. In another embodiment, the databasesystem performs such changes asynchronously, so that an over-large chunkis split into a first and second chunk as a “background” task of thesystem. Further, in another embodiment, this second chunk is createdwhen an insert occurs to a time value that is sufficiently close to theend of a chunk's time range, rather than only when a record's dimensionattributes (e.g., time) fall outside the dimensions of any existingchunks. In general, many of the variations of the database system'schunk management may be performed either synchronously at insert time orasynchronously as a background task. Size- and interval-based chunkingis further described below.

In an embodiment, the chunk creation module 450 performs collisiondetection to ensure that the new chunks(s) have sets of dimensionattributes that are disjoint from existing chunks. For example, assumethat the chunk creation module is creating chunks with a time rangespanning 24 hours. If the previous chunk stored data with time attributevalues until midnight (exclusive) on a date January 1, the chunkcreation module 450 next creates chunks with time attribute values frommidnight (inclusive) on January 2 to the following midnight (exclusive).As another example, if the chunk creation module 450 is creating chunkswith 18-hour intervals of time attribute, if the previously createdchunk covered a time interval from midnight to 3 am, the chunk creationmodule 450 next creates a new 18-hour chunk spanning a time intervalfrom 3 am to 9 pm for the time attribute. The chunk creation module 450can create multiple chunks having the same time range but havingdifferent sets of values for other dimension attributes.

The chunk creation module 450 may adjust chunk boundaries based onvarious criteria, some of which may be conflicting. As an example,consider that the database system has one chunk with a time intervalthat ends at 3 am, and another chunk from noon to the followingmidnight. The database system may next receive a request to insert arecord having a time attribute value of 4 am. Even if the chunk creationmodule 450 may be creating chunks with a time range spanning 12 hours,in this scenario, the chunk creation module 450 may create a new chunkspanning only a 9 hour time interval from 3 am to noon in order toenforce disjointness. In some embodiments, the chunk management module170 determines after a chunk is created that the ranges (or set ofvalues) of the chunk are likely to overlap other chunks created. Inthese embodiments, the chunk management module 170 modifies the existingranges of the chunk to ensure that the ranges are disjoint from otherchunks.

In some embodiments, across different partitions, the database systemmay align chunk start and end times or maintain them independently. Inother words, the system may create and/or close all of a hypertable'schunks at the same time, or different partitions can be manageddistinctly from one another. In other embodiments, there may be specialoverflow chunks where data that cannot be placed in some existing chunksis placed either temporarily or permanently.

The system architecture illustrated in these figures (for example, FIGS.1-4) are meant to be illustrative; other embodiments may includeadditional or fewer components, some of these components might notalways be present (e.g., a query parser or cache), or these componentsmay be combined or divided in a variety of way (e.g., the query planner,query optimizer, and execution engine). It is understood that such arepresentation or division would not change the overall structure andfunction of the database system. For example, one would understand thatthe methods described herein could be implemented in a system thatincludes one component performing both query planning and executing, orin a system that includes a separate component for planning, which thenpasses the plan to an executor engine for execution.

Inserting Data in a Hypertable

FIG. 5 illustrates the process of inserting records into a hypertablestored across a plurality of database system nodes, in accordance withan embodiment. The database system 110 receives 510 an insert query(which we also call an insert request). The insert query identifies adatabase table, for example, a hypertable, chunk, or a standardnon-partitioned database table and specifies one or more records to beinserted into the database table. The database system 110 may storerecords as a hypertable comprising a plurality of chunks, each chunkstored in a distinct location.

Upon receiving 510 the insert query, the query parser 415 parses theinsert query. The query planner 425 processes the query, and determinesif the query specifies a hypertable, chunk, or a standardnon-partitioned database table. If the insert query specifies a standarddatabase table or a chunk, the query planner 425 executes the insert onthe specified chunk or the standard database table in conjunction withthe execution engine 435 and returns the result(s).

If the query specifies a hypertable, the query processor 130 performsthe following steps for each record specified in the insert request. Thequery processor 130 identifies the values of the dimension attributes inthe input record. The query processor 130 determines whether the inputrecord should be stored in an existing chunk or in a new chunk thatneeds to be created. In an embodiment, the query processor 130determines whether the one or more dimension values of the input recordmap to values from the set of dimension attribute values of existingchunks storing data of the hypertable; this determination is made todecide whether the record can be stored in an existing chunk.

In an embodiment, the query processor 130 provides 520 the dimensionattributes as input to a selection function of the chunk selectionmodule 445 that determines whether the record should be stored in anexisting chunk or whether a new chunk needs to be created for storingthe record. If the selection function finds an existing chunk thatmatches the record, the selection function outputs informationidentifying the existing chunk. If the selection function determinesthat none of the existing chunks can be used to store the record, theselection function outputs a value (for example, a negative number)indicating that a new chunk needs to be created. The chunk creationmodule 450 determines 540 based on the output of the selection function,if the record matches an existing chunk. If the chunk creation module450 determines 540 that the record matches an existing chunk, the chunkselection module 445 also identifies the location of the existing chunk,for example, whether the existing chunk is local (i.e., on the currentdatabase system node) or remote (i.e., on another database system node).This location can specify a location explicitly or implicitly, includingspecifying a name of a local database table, the name of a remotedatabase table, the name or network address or a remote server, and soon. Accordingly, the query processor 130 inserts 550 the record in theexisting chunk.

If the chunk creation module 450 determines 540 based on the output ofthe selection function that a new chunk needs to be created for storingthe record, the chunk creation module 450 determines 560 a configurationof the new chunk comprising sets of values corresponding to differentdimension attributes for the new chunk. The chunk creation module 450may further identify a location for creating the new chunk (includingidentifying a specific storage device or instead identifying a specificdatabase system node, wherein the identified node in turn identifies aspecific storage device attached to it). The chunk creation module 450creates a new chunk based on the configuration of the new chunk and theidentified location. The query processor 130 inserts 580 the record inthe new chunk that is created.

The chunk selection module 445 may determine that a record cannot beinserted in an existing chunk based on various criteria. A record cannotbe inserted in any existing chunk if the dimension attributes of therecord do not match the configurations of any existing chunks. In someembodiments, even if the dimension attributes of the record match theconfiguration of an existing chunk, the chunk selection module 445 maydetermine that the record cannot be inserted into the chunk based oncertain policy considerations. For example, the chunk selection module445 may determine that the existing chunk is storing more than athreshold amount of data and no new records should be added to thechunk. Accordingly, the chunk selection module 445 determines that therecord cannot be added to the existing chunk and the database systemcannot insert the record in any existing chunk.

To create a chunk locally or to insert the record in a chunk storedlocally, i.e., on the current database system node executing the abovesteps, the database system may perform a function call. To create achunk remotely or to insert the record in a chunk stored remotely, i.e.,on a database system node different from the current database systemnode, the database system may perform a remote call, for example, aremote procedure call (RPC) or a remote SQL query execution. Theinstructions executed for creating a chunk or inserting a record into achunk may also depend on the location of the chunk, for example, thetype of storage medium used for storing the chunk.

Although FIG. 5 describes the steps in terms of a selection function,other embodiments can use different functions to compute differentvalues, for example, a first function to determine whether the recordshould be stored in an existing chunk and a second function to describea new chunk if the first function determines that the record cannot bestored in any existing chunk.

If multiple chunks reside on the same location, rather than using aseparate message for each insert query, the query processor 130 may sendmultiple queries in a single message, or it may also send the multiplerecords to be inserted in a single query in a single message. If thechunks involved in an insert query reside on multiple nodes, in someembodiment the database system node contacts a query or transactioncoordinator for additional information that is used and/or transmittedwhen subsequently communicating with other database nodes as part of theinsert process.

In some embodiments, the query processor 130 handles a lack of a timelyresponse or an error in a variety of ways. If a chunk is replicatedbetween multiple nodes, or the record-to-chunk determination processresults in more than one chunk, the query processor 130 issues an insertrequest to one or more of these chunks, discussed further. Finally, thequery planner 425 collects any result(s) or status information from theinsert queries, and returns some result(s) or status information to therequester.

In some embodiments, the database system 110 performs several steps todetermine the chunk to which a record belongs, many of which involveusing metadata. First, the query planner 425 determines the set of oneof more partitions that belong to the hypertable at the time specifiedby the record (i.e., the value of the record's time attribute). If thispartitioning is static, the query planner 425 uses metadata about thehypertable itself to determine this partitioning.

If this partitioning changes over time, the query planner 425 uses therecord's time attribute to determine the set of partitions. In oneembodiment, this determination involves first using the row's timeattribute value to determine a particular epoch (time interval), thenusing this epoch to determine the set of partitions. This partitioningmay change in the context of system reconfiguration (or elasticity) asdescribed below. Second, the query planner 425 determines the partition(from amongst this set of one or more partitions) to which the recordbelongs, using the value(s) of the record's dimension attribute(s). Foreach of the dimension attributes used for partitioning in thehypertable, this step may involve applying some function to its value togenerate a second value. A variety of functions may be employed for thispurpose, including hash functions (e.g., Murmur hashing, Pearsonhashing, SHA, MD5, locality-sensitive hashing), the identity function(i.e., simply return the input), a lookup in some range-based datastructure, or some other prefixing or calculation on the input. Third,using this second value (the function's output), the query planner 425determines to which partition the second value belongs. For example,this step could involve a range lookup (e.g., find the partition [x, y]such that the second value is between x and y, inclusive and/orexclusive), a longest-prefix match on the partition (determine thepartition that, when represented by some binary string, has the greatestnumber of most significant bits that are identical to those of thesecond value), taking the second value “mod” the number of nodes todetermine the matching partition number, or the use of consistenthashing, among other matching algorithms. If the hypertable ispartitioned using more than one key, then a function could be applied tomore than one input (or functions could be separately applied tomultiple inputs), leading to one or more second values (outputs) thatwould be used to determine the partition to which a record belongs.Finally, each partition for each dimension is associated to a set ofchunks (i.e., those chunks which store this partition yet may differ intheir time ranges); the query planner 425 then determines a chunk fromthis set based on the record's time attribute.

Other embodiments implement the step of determining the chunk to which arecord belongs in alternate ways. For example, the database system skipsthe process of first determining a record's chunk based on its epoch,and instead first determines a set of chunks associated with therecord's time. The query planner 425 computes a function on the record'spartition key(s) to determine the second value(s), and compares thissecond value against the partition information associated with eachchunk in order to select one. These processes can be implemented via avariety of data structures, including hash tables, linked lists, rangetrees, arrays, trees, tries, etc.

There are a variety of other optimized ways to implement the process bywhich the query planner 425 inserts a batch's data into chunks, withoutchanging its basic functionality. For example, rather than performingall these steps for every record, the query planner 425 can cacheinformation it determines during its per-record analysis, such as thehypertable's chunks for a given time or time period.

Other embodiments perform the steps for processing a batch in differentways. For example, after determining the first record's chunk, the queryplanner 425 scans through the rest of the batch, finding all otherrecords associated with the same chunk (if any exist). The query planner425 then inserts these records into the selected chunk, and deletes themfrom the batch. The query planner 425 then repeats this process:selecting a record in the (now smaller) batch, scanning the rest of thebatch to find records with a similar chunk association, sending that setof one or more records to the second chunk, and then repeating thisprocess until the batch is empty.

The insertion process above describes a record as being associated witha single chunk. Alternatively, a record could map to multiple chunks.For example, the chunking process might create more than one chunkduring a particular interval (e.g., if the size of inserted data exceedssome threshold), as described herein, in which case the selectionfunction chooses one, e.g., randomly, round robin, or based on theirsizes. As another example, the database chooses to insert the recordinto multiple chunks to replicate data for reliability or highavailability. Such replication can be performed by the query planner 425as part of the same steps described above, or the query planner 425first inserts each of the records into a primary chunk, and then thedatabase system 110 replicates the inserted record to the chunk'sreplica(s).

In an embodiment, the database system 110 replicates the chunks suchthat different chunks of the same hypertable may be stored with adifferent number of replicas. Furthermore, the database system maydetermine the number of replicas for a chunk based on the age of thechunk. For example, recent chunks may be replicated a greater number oftimes than older chunks. Furthermore, older chunks that have more than athreshold age may not be replicated. The database system 110 maydetermine the age of a chunk based on the values of the time attributeof the chunk. For example, a chunk that stores records having timeattribute within a range [t1, t2] may be determined to be older than achunk that stores records having time attribute within a range [t3, t4]if the time range [t1, t2] is older than the time range [t3, t4], forexample, t2<t3. Alternatively, the age of the chunk may be determinedbased on the time of creation of the chunk. For example, a chunk createda week ago has an age value that is greater than a chunk created today.

In an embodiment, the database system replicates different chunks tolocations having different characteristics. The database system selectsa location having particular characteristics based on the configurationof the chunk. For example, the database system stores and/or replicatesrecent chunks which are regularly being accessed (for inserts orselects) on fast storage media (e.g., SSDs), while the database systemstores and/or replicates old chunks on slower storage media (e.g.,HDDs).

In an embodiment, the database system reuses replication techniques thatapply to the database's underlying tables, namely, physical replicationof the entire database and cold/hot standbys, logical replication ofindividual tables, as well as backups. It also uses the database'swrite-ahead log (WAL) for consistent checkpointing. In other words, eventhough replication or backup policies are defined (or commands issued)on the hypertable, the system performs these actions by replicating orcheckpointing the hypertable's constituent chunks. In anotherembodiment, replication and high availability is implemented directly bythe database system by replicating writes to multiple chunk replicas(e.g., via a two-phase commit protocol), rather than by using thedatabase's underlying log-based techniques.

In an embodiment, the database system allows different policies to bedefined based on chunk boundaries, e.g., a higher replication level forrecent chunks, or a lower replication level on older chunks in order tosave disk space.

In an embodiment, the database system also moves chunks betweenlocations when they age (e.g., from being stored on faster SSDs toslower HDDs, or from faster or larger servers to slower or smallerservers). The database system associates each hypertable with athreshold age value. The database system further associates locationswith types. For example, different types of locations may have differentaccess time, different storage capacity, different cost, and so on. Ifthe database system identifies a chunk of the hypertable having an agevalue greater than the threshold age value of the hypertable, thedatabase system moves the identified chunk from a location having aparticular type to another location having a different type. As a resultthe database system may store different chunks of the same hypertable indifferent types of location. Furthermore, the database systemautomatically changes the mapping of the chunks of the hypertable tolocations over time as newer chunks are received and existing chunks getolder. In another embodiment, this movement only happens when requestedby a command (e.g., from an external process or database user), whichspecifies the age associated with the hypertable and the locationsbetween which to move any selected chunks.

Processing Queries Reading Data

FIG. 6 is a flowchart of the process of executing a query for processingrecords stored in a hypertable, in accordance with an embodiment. Thedatabase system receives 610 a query for reading data (e.g., via aSELECT statement in SQL). Upon receiving a query, the query parser 415parses the query (optionally using a cache of parsed queries). The queryplanner 425 processes the query and determines if any table specified inthe query corresponds to a hypertable, chunk, or a standardnon-partitioned database table. The database system performs thefollowing steps in these different scenarios, each resulting in someresult being returned to the requester (or some form of error if anyproblems occur).

For every hypertable specified in the first query, the query planner, inconjunction with the execution engine 435, performs the following steps.First, the query planner 425 analyzes the query to determine 620 the setof chunks that may contribute results to the query's answer. Thisanalysis typically involves the constraints specified by the query'spredicates as well as metadata that the database system 110 maintainsabout chunks. For example, these constraints may be based on the valueof a particular field (e.g., selected rows must have a device identifierthat equals either 100 or 450), or they may include some type of timerange (e.g., selected rows must specify that their time value is withinthe past hour, or between July 2016 and August 2016). Metadata storedabout each chunk may specify, among other things, the range of time andany other partitioning key(s) associated with a particular chunk. Forexample, a chunk might be storing the last day of data for deviceidentifiers between 0 and 200. These examples are simply illustrativeand a variety of techniques that the system may employ are describedherein. The query planner 425 uses the metadata to determine theappropriate chunks, e.g., a device identifier of 100 will be associatedwith the chunk storing device identifiers between 0 and 200.

The following steps 630, 640, 650, and 660 are repeated for each chunkdetermined. The query planner 425 uses metadata to determine thelocation(s)—e.g., storage devices such as local or network-attacheddisk(s), or other database system node(s)—at which these chunk(s) arebeing stored. These chunks may be stored on a location local or remoteto the query planner 435. The query planner 425 determines 640 whetherthe chunk is stored locally or on a remote server. If the query planner425 determines that the chunk is stored in a local location, the queryplanner 425 queries the local chunk (e.g., via direct function calls) orelse the query planner 425 sends 660 a query to the remote locationstoring the chunk (e.g., by issuing SQL queries such as via foreign datawrappers, by sending remote procedure calls (RPCs), etc.). Furthermore,the query planner 425 may change the query execution or plan dependingon the properties of the location that stores them (e.g., type of diskor node). When multiple chunks share the same location, the queryplanner 425 can generate a single query for the location's set of chunksor a separate query per chunk, and these separate queries can be sent ina single message to the location or as a separate message per query.

The query planner 425 issues queries to these locations and waits fortheir results. If some locations are not responding after some time orreturn errors, the query planner 425 can take several different options,including retrying a query to the same location, retrying a query to adifferent location that replicates the chunk, waiting indefinitely,returning a partial result to the client, or returning an error. Thequery planner 425 receives 670 or collects the results of these queriesand merges the results. Depending on the query, the results, metadata,and additional information, the query planner 425 optionally maydetermine that it needs to query additional chunks to resolve the firstquery (e.g., when “walking back in time” from the latest time intervalto older intervals in order to find some number of values matching aparticular predicate).

Depending on the query, the query planner 425 may perform 680post-processing of the results. Such post-processing includes taking aunion over the returned results, performing an aggregation like a SUM orCOUNT over the results, sorting the merged results by a specific field,taking a LIMIT that causes the system to only return some number ofresults, and so on. It may also involve more complex operations inmerging the chunks' results, e.g., when computing top-k calculationsacross the partial results from each chunk. Finally, the system returnsthe result(s) of this first query. The result of the query may compriseone or more tuples or an error code if the processing of the queryresulted in an error.

In some embodiment, a query across multiple database nodes may alsoinvolve the use of a query or transaction coordinator, such that thecoordination is contacted for additional information that is used and/ortransmitted when subsequently communicating with other database nodes aspart of the query process.

A node may also receive a query to a chunk or chunks, e.g., because itis the recipient of a query generated by the processing of the firstquery to a hypertable. For every chunk specified in the query, the queryplanner 425 performs the following steps. The query planner 425 plansand executes the query on the local chunk. This uses query planningtechniques including choosing and optimizing the use of indexes,performing heap scans, and so forth. The query planner 425 receives theresults of the query. Third, depending on the query, the query planner425 may also post-process the results (e.g., sorting the data,performing an aggregation, taking the LIMIT, etc. as described above).It then returns the query's result(s).

A database system node may receive a query to a traditional databasetable, which involves processing the query in a standard way: planningand executing the query on the specified table, receiving the results,post-processing the results optionally, and returning the result(s).

The query may also specify multiple tables or joins between tables. Thedatabase system's processing depends on the types of tables specified(e.g., hypertables, chunks, standard non-partitioned tables) and isrelated to the steps above, although individual steps may differ oradditional steps may be required based on the actual query.

Alternative Embodiments for Processing Queries Based on Hypertables

Ideally database users should be able to interact with time-series dataas if it were in a simple continuous database table. However, forreasons discussed above, using a single table does not scale. Yetrequiring users to manually partition their data exposes a host ofcomplexities, e.g., forcing users to constantly specify which partitionsto query, how to compute JOINs between them, or how to properly sizethese tables as workloads change.

To avoid this management complexity while still scaling and supportingefficient queries, the database system hides its automated datapartitioning and query optimizations behind its hypertable abstraction.Creating a hypertable and its corresponding schema is performed usingsimple SQL commands, and this hypertable is accessed as if it were asingle table using standard SQL commands. Further, just like a normaldatabase table, this schema can be altered via standard SQL commands;transparently to the user, the database system atomically modifies theschemas of all the underlying chunks that comprise a hypertable.

In an embodiment, the database system provides this functionality byhooking into the query planner of a relational database like PostgreSQL,so that it receives the native SQL parse tree. It uses this tree todetermine which servers and hypertable chunks (native database tables)to access, how to perform distributed and parallel optimizations, etc.

Many of these same optimizations even apply to single-node deployments,where automatically splitting hypertables into chunks and related queryoptimizations still provides a number of performance benefits. This isespecially true if the chunks are distributed across the variouslocations of a node (e.g., across multiple local or network-attacheddisks). In an embodiment, the placement of chunks on database nodes isspecified by commands or policies given by database administrators orusers.

In an embodiment, the database system partitions its hypertable in onlya single dimension—by time—rather than two or more dimensions (forexample, time and space dimensions). For example, partitioning based ona single time dimension may be used for deployments of the databasesystem on a single node rather than a cluster of nodes.

Additionally, hypertables can be defined recursively. In particular, ahypertable's chunk can be further partitioned (by the same or differentpartitioning key, and with the same or different time intervals) andthus act like another hypertable.

Chunks are dynamically created by the runtime and sized to optimizeperformance in both cluster and single-node environments. Partitioning ahypertable along additional dimension attributes (in addition to time)parallelizes inserts to recent time intervals. Similarly, query patternsoften slice across time or space, so also result in performanceimprovements through chunk placements disclosed herein.

The placement of these chunks can also vary based on deployment,workload, or query needs. For example, chunks can be randomly orpurposefully spread across locations to provide load balancing.Alternatively, chunks belonging to the same region of the partitioningfield's keyspace (for example, a range of values or hashed values, or aset of consecutive values of the key), yet varying by time intervals,could be collocated on the same servers. This avoids queries touchingall servers when performing queries for a single object in space (e.g.,a particular device), which could help reduce tail latency under higherquery loads and enable efficient joins.

The database system determines where a chunk should be placed when it iscreated; this determination is based on a variety of one or moremetrics, including performed randomly or via a round-robin distributionstrategy, based on server load (e.g., request rate, CPU utilization,etc.), based on existing usage (e.g., size of existing chunks in bytesor number of rows), based on capacity (e.g., total memory or storagecapacity, free memory, available storage, number of disks, etc.), basedon configured policy or specified by an administrator, and so forth. Thedatabase system or administrator may also choose to relocate (move) orreplicate chunks between servers.

Even in single-node settings, chunking still improves performance overthe vanilla use of a single database table for both read and writequeries. Right-sized chunks ensure that most or all of a table's indexes(e.g., B-trees) can reside in memory during inserts to avoid thrashingwhile modifying arbitrary locations in those indexes. Further, byavoiding overly large chunks, the database system avoids expensive“vacuuming” operations when removing data, as the system can performsuch operations by simply dropping chunks (internal tables and/orfiles), rather than deleting individual rows. For example, this removalmay be the result of data deletions (e.g., based on automated dataretention policies and procedures), or it may be the result of a largebatch insert that fails or is interrupted (which the non-committed rowsneeding to subsequently be removed). At the same time, avoidingtoo-small chunks improves query performance by not needing to readadditional tables and indexes from disk, or to perform query planningover a larger number of chunks.

The database system considers a few factors for determining a chunk'ssize. First, the database system maintains metadata that specify thenumber of partitions into which an additional partitioning field splitsa particular time interval. For example, 10 machines each with 2 disksmight use 20 partitions (or multiple partitions per server and/or disk).This implies that the keyspace of a particular field (e.g., a device ID,IP address, or location name) is divided into 20 ranges or sets. Thedatabase system then determines to which range (or partition) aparticular value is associated by performing a lookup or comparisonprocess. In one embodiment, the field is a string or binary value, andthe database system splits the keyspace by prefix of the values of thefield, then maps a value to one of these partitions based on thepartition that shares the longest common prefix. Alternatively, thedatabase system uses certain forms of hashing, such that the hashoutput's space is divided again into a particular number of ranges orsets (e.g., contiguous ranges, sets defined by splitting the entire hashoutput space, sets defined by taking the hash output space “mod” thenumber of nodes, sets defined by consistent hashing, etc.). The databasesystem applies a hash function to the input value to yield an outputvalue; the database system determines the range or set that includes theoutput value, which then corresponds to the partition to which the inputvalue belongs. The database system may use a variety of functions insuch a context, including hash functions (e.g., Murmur hashing, Pearsonhashing, SHA, MD5, locality-sensitive hashing), the identity function(i.e., simply return the input), or some other prefixing or calculationon the input.

Second, once the number of partitions based on partitioning keys isdetermined—and in fact, this number can change over time due toelasticity, discussed below—then the time-duration of the chunk alsodetermines its size. For a constant input rate and some given number ofpartitions, a chunk with a hour-long time interval will typically bemuch smaller than one with a day-long interval.

In one embodiment, the database system makes the time intervals staticor manually configurable. Such an approach is appropriate if the datavolumes to the system are relatively stable (and known), and thisprovides the database administrator or user with control over thedatabase system's operation. But, such fixed time intervals may not workas well as data volumes change—e.g., a time interval appropriate for aservice pulling data from 100 devices is not appropriate when thatsystem scales to 100,000 devices—or require care that the administratoror user change interval sizes over time (either to apply to futureintervals or to split existing intervals into multiple chunks).

In one embodiment, the database system determines chunks' time intervalsdynamically based on chunk sizes, rather than based on a fixed timeinterval. In particular, during insert time, the database systemdetermines if a chunk is approaching or has exceeded some thresholdsize, at which time it “closes” the current chunk and creates a newchunk (e.g., by using the current time as the ending time of the currentchunk and as the starting time of the new chunk).

This threshold size is given a default in software configuration, thisdefault can be configured by the database system administrator, and thissize can be changed by the administrator or the database system's logicduring runtime (so that chunks in the same database system can havedifferent threshold sizes). In an embodiment, the database system chosesthe size as a function of the system's resources, e.g., based on thememory capacity of the server(s), which may also take into account thetable schema to determine the amount of indexing that would be neededand its size requirements. This tuning takes into account realized orpotential changes in the schema over time. For example, if indexes areadded to many fields (columns), the amount of memory needed to storethese fields changes, which leads the database system to use smallerchunks; if many fields are not indexed, the database system may accountfor these differently than a schema without any unindexed fields (asindexes may later be added to these fields to enable more efficientqueries). Alternatively, recognizing that the database ultimately storestables in files in the underlying file system that have a maximum size(e.g., 1 GB), the system ensures that the chunk size is smaller thanthis maximum size. In an embodiment, the size is chosen as a measured orestimated result of read/write performance on the chunk size.

In some embodiments, the database system creates a new chunk even whenthe current chunk size is less than some threshold (i.e., it is“approaching” the threshold, and has not yet exceeded or equaled it), inorder to leave some “free space” for the possibility ofout-of-time-order data that the database system must backfill into anolder chunk. When writing to an older or “closed” chunk, differentembodiments of the database system allow the chunk to grow arbitrarilylarge, create a new overlapping chunk just for the newly written excessdata, or split the existing chunk into two, among other approaches. Ifoverlapping chunks are created, the database system follows its policiesfor writing and reading to overlapping chunks.

In another embodiment, the database system determines a chunks' timeintervals dynamically based on historical intervals and their sizes. Inthis case, new chunks are created with an end time, but that end time isautomatically set by the database system based on the resulting size ofearlier chunks that had a certain interval duration. For example, if thedatabase system (or user or administrator) desires chunks of sizeapproximation 1 GB, and the previous 12 hour chunk resulted in a chunkof size 1.5 GB, then the database might create a subsequent chunk ofsize 6 hours. The database system can continue to adapt the intervals ofchunks during its operation, e.g., to account for changing data volumesper interval, to account for different target sizes, etc.

In some embodiments, the database determines chunks based on a hybrid oftime intervals and threshold sizes. For example, the database system (oradministrator) specifies that a chunk have a pre-determined timeinterval—so that, as described above, the start and end time of a chunkare specified at creation time—but also that a chunk also have a maximumsize in case the insert rate for that interval exceeds some amount. Thisapproach avoids a problem with chunking based purely on fixedtime-intervals in scenarios where system load per interval changes overtime. If the chunk's size approaches or exceeds its maximum permittedthreshold during the middle of the current time interval, the databasesystem creates a new chunk that overlaps the same interval, or thedatabase system switches to the use of a different time interval. Forthe former, both chunks represent the same interval, so inserts couldchoose to write to one of them (while reads query both of them). For thelatter, the database system may change a chunk's time interval tosomething smaller, and create a new non-overlapping chunk to succeed itin time. As described earlier, such chunk management may be performedsynchronously or asynchronously, e.g., a background task splits anover-large chunk into two chunks.

Such chunking may also limit the pre-determined time intervals toregular boundaries (e.g., 1 hour, 6 hours, 12 hours, 24 hours, 7 days,14 days), rather than arbitrary ones (e.g., 11 minutes, 57 minutes).This embodiment causes chunk intervals to align well with periods oftime on which data might be queried or deletions might be made, e.g.,according to a data retention policy such as “delete data more than 12hours old”. That way, the database system implements such policies bydropping entire chunks once their records are all at least 12 hours old,rather than partially deleting individual rows within chunks: droppingentire chunks (database tables) is much more efficient than deleting anequivalent number of rows within a table.

The database system selects these boundaries in a manner that theboundaries compose well, e.g., they are multiples of one another or arealigned in some other ways. The switching between various interval sizesis performed automatically by the database runtime (e.g., in response tochanging data rates) or through configuration by a user oradministrator. Similarly, rather than always closing a chunk andcreating a new one based on an automated policy, an administrator maysignal the database system to create a new chunk or chunk interval via aconfiguration command.

In one embodiment, the database system also applies such adaptation ofthe chunk's configuration to non-time dimension attributes that are usedto define a chunk's ranges. For example, if a hypertable's partitioningis also performed on a field representing a device id, the databasesystem can increase the number of partitions (sets of values) defined onthis field from 10 to 20. Such a change, which may be performedautomatically by the database system or through configuration by a useror administrator, can be used to increase hypertable performance. Forexample, if queries typically specify a single device id from which toSELECT data, the query's latency can be improved if the chunks thatcontain the specified device include information about a fewer otherdevices, which can be made to occur by increase the number of partitionsover the device id field.

In another embodiment, the database system can employ different timeintervals across different partitions. For example, if a hypertable'spartitioning is also performed on a field representing a customer id(e.g., where each distinct customer id is a separate partition), thenthe database system may independently maintain different time intervals(when partitioning on the time attribute) for different customer ids.Such an approach can be beneficial if different customers have verydifferent insert and select query patterns, as well as different dataretention needs.

In general, the database system employs a variety of methods for chunkmanagement, given that there are multiple different goals andengineering trade-offs between approaches. These goals includeoptimizing sizes, aligning time intervals for dropping chunks whileretaining data integrity, minimizing locking or other performancepenalties due to mutability, avoiding arbitrary-sized intervals,creating chunk boundaries that are most advantageous for constraintexclusion, increasing system parallelism, improving query performance,and simplifying code, operation, and management complexity, amongothers. Different deployments of the database system may choose to usedifferent approaches based on their setting and needs.

Adjusting Partitioning Policies in View of System Reconfiguration

The amount of data stored in a database systems 110 increases over time.For example, large amount of time series data may be received by adatabase system 110 and stored in database tables. Database systems 110often reconfigure the system to increase the storage capacity, forexample, by adding storage devices. Conventional systems adapt to thechange in the system configuration by moving data. For example, a systemmay get reconfigured as a result of addition of new servers and may movesome chunks of data from existing servers to the new servers, in orderto ensure that the new servers are bringing additional capacity to thesystem. As a result, a large amount of data is moved, thereby making thesystem reconfiguration an expensive and time-consuming process. This newconfiguration of participating servers is also referred to as a “view”which represents the set of servers and their configuration, such as theservers' capacity or number of disks. The ability of a system to adaptto changes in computing resources so as to be able to effectively useall available resources if referred to as elasticity.

Embodiments of the database system 110 adapt to reconfiguration of thesystem without performing such data movement. In particular, thedatabase system 110 provides elasticity by creating a new set of chunksand partitioning when the database system is reconfigured for increasingthe storage capacity. The database system may use a differentpartitioning policy for the new set of chunks that are created after thesystem is reconfigured. For example, if the previous partitioning policycreated 20 partitions for 10 servers, the new partitioning policy mightcreate 30 partitions to take into account 5 new servers that are addedto the database system. In another example, the previous partitioningpolicy may create 20 partitions to place 5 partitions on each of 4servers, but when an additional 1 server is added, the new partitioningpolicy may then place 4 partitions on each of the 5 servers. In someembodiments, the database system distributes a plurality of chunkscreated such that new servers are assigned more chunks from theplurality of chunks than existing servers. This allows better balancingof load across the servers. In another embodiment, new servers areassigned larger chunks compared to chunks assigned to existing servers.Larger chunks have configuration that allows them to potentially storemore data than smaller chunks. Data can still be read or written topreviously created chunks or the newly created chunks. Because writes totime-series datasets are typically made to the latest time interval, andmany query workloads also process recent data, load balancing across thenew set of servers is still maintained, even without moving the existingdata.

FIGS. 7(A-B) illustrate partitioning of data of a database table toadapt to the addition of locations to the database system according toan embodiment of the invention.

As illustrated in FIG. 7(A), the database system 110 can have aplurality of storage locations 710 a, 710 b, 710 c, and 710 d. FIG. 7illustrates the distribution of data of a database table with attributescomprising a time attribute and a space attribute (recall that we usethe term “space” partitioning to signify any partitioning over anon-time attribute). In response to requests to insert records in thedatabase table, the database system 110 distributes data of the databasetable according to a partitioning policy that assigns chunks 210 tolocations 710. In the example, configuration shown in FIG. 7(A), thedatabase system 110 creates a plurality of chunks including 210 a, 210b, 210 c, and 210 d and assigns one chunk to each location. The chunksare distributed across the locations of the database system 110 alongthe time and space attributes. Accordingly, each chunk is associatedwith a time range and a space range and stores records that have timeand space attributes that lie within the time and space ranges of thechunk. In the example configuration shown in FIG. 7, each of the chunks210 a, 210 b, 210 c, and 210 d is associated with the same range of timeattribute, i.e., [0, 6] but has a different range of the spaceattribute. For example, chunk 210 a has space range [A, F], the chunk210 b has space range [G, L], the chunk 210 c has space range [M, S],and the chunk 210 d has space range [T, Z].

FIG. 7(B) shows the partitioning of the chunks of the database tableafter some time has passed, such that the database system has receivedrequests to insert records with a time attribute later than 6. Inresponse to receiving requests to insert records with a time attributeof 7, for example, the database system creates a new plurality ofchunks, 201 e, 210 f, 210 g, and 210 h. The new plurality of chunks aredistributed across the locations according to the same partitioningpolicy as above. According to this partitioning policy, each chunk fromthe new plurality of chunks is associated with a new time range [7, 15].In this illustration, the chunks stored in the same location have thesame space range. For example, both chunks 210 a and 210 e assigned tolocation 710 a have the space range [A, F], both chunks 210 b and 210 fassigned to location 710 b have the space range [G, L], and so on. Thedatabase system could also assign chunks with different time intervalsbut the same space range to different locations.

FIG. 7(C) shows the partitioning of the chunks of the database tableafter a new location 710 e is added to the database system 110. As aresult, the database system 110 has a plurality of locations thatinclude locations 710 a, 710 b, 710 c, 710 d, and 710 e. Although FIG. 7shows a single location being added to the database system, more thanone locations may be added to increase the storage capacity of thedatabase system 110. In response to addition of the new location, thedatabase system 110 uses a new partitioning policy to distribute recordsacross the locations. Accordingly, in response to receiving subsequentinsert requests, e.g., with values for dimension attributes that do notmap to any of the existing chunks, the database system 110 creates aplurality of chunks including 210 i, 210 j, 210 k, 210 l, 210 m, and 210n. The chunks 210 i, 210 j, 210 k, 210 l are mapped to the locations 710a, 710 b, 710 c, 710 d, and chunks 210 m and 210 n are both mapped tothe new location 710 e. In other embodiments, the database system mayassign more or fewer chunks to the new locations that are added.Accordingly, subsequent records received are distributed according tothe new partitioning policy. In the embodiment illustrated in FIG. 7,the database system 110 does not move any data that was stored in thechunks that were created before the new locations were added. However,the chunks that are created responsive to the addition of the newlocations are distributed according to a new partitioning policy thatbalances storage of data across all available locations. In the example,shown in FIG. 7(C), more chunks are assigned to the new location(s)since the storage and computing resources of the new locations arelikely to be underutilized compared to the existing locations that havepreviously stored data. However, over time, as additional data getsstored on the new locations, the utilization gap between the newlocations and existing locations reduces without having to move any datafrom the existing locations to the new locations.

As illustrated in FIG. 7(C), the new partitioning policy creates aplurality of chunks that has more chunks after new locations are added.Accordingly, each space range is smaller in the new partitioning policycompared to the space ranges of the portioning policy used beforeaddition of the new locations.

In another embodiment, the database system assigns a larger fraction ofnew data to the new locations not by assigning a larger number of chunksto those locations, as shown in FIG. 7(C), but by assigning chunks withdimension ranges that have a larger set of values. For example, ratherthan having chunk 210 m with the space range [Q, U] and chunk 210 n withthe space range [V, Z], the database system could create a single chunkassigned to location 710 e with a space range [Q, Z].

In some embodiments, when the database system 110 detects that newlocations are being added to the database system, the database system110 dynamically changes the partitioning based on the new storageconfiguration. In other embodiments, the partitioning policy isconfigured by a user, for example, a database system administrator.

A partitioning policy determines how new chunks are created and assignedto locations for storing them. For example, if a partitioning policy isbeing enforced and new chunks need to be created (for example, to insertrecords than cannot be inserted in existing chunks), a plurality ofchunks may be created and distributed according to the partitioningpolicy. The partitioning policy may specify various aspects of creationof new chunks including the number of chunks being created, theconfigurations of individual chunks being created (the configurationcomprising the sets of values of different dimension attributes for eachchunk), and the mapping of the chunks to locations.

The partitioning policy may store information specifying various aspectsof the chunk creation/distribution as metadata, for example, the mappingfrom chunks to locations may be stored using a mapping table thatexplicitly stores locations for each chunk being created. Alternatively,the partitioning policy may specify various aspects of chunkcreation/distribution using instructions, for example, the partitioningpolicy may specify mapping from chunks to locations using a function (ora set of instructions) that determines a location for a chunk given thechunk configuration and potentially other system information as input.Different partitioning policies may specify different mapping functions(or sets of instructions). Alternatively, different partitioningpolicies may use the same mapping function (or sets of instructions) butpass different parameter values as input. Such mapping functions (orsets of instructions) may include random selection, round-robinselection, hash-based selection, selection based on the number, size, orage of chunks being stored, selection based on the age of when thelocation was added to the database system, load balancing strategiesbased on server resources (including insert or query rates, CPUcapacity, CPU utilization, memory capacity, free memory, etc.), loadbalancing strategies based on disk resources (including total diskcapacity, unused disk space disk, disk TOPS capacity, disk TOPS use,etc.), and other criteria or algorithmic approaches, as well as somecombination thereof. A partitioning policy may use a combination of theabove techniques.

In an embodiment, a partitioning policy specifies the size of theplurality of chunks being created. The size of the plurality of chunksmay represent the number of chunks in the plurality of chunks beingcreated. Alternatively, the size of the plurality of chunks mayrepresent the aggregate size of chunks in the plurality of chunks beingcreated, where the size of each chunk represents a measure of the amountof data that can potentially be stored in the chunk. The size of a chunkis determined based on the configuration of the chunk comprising thesets of values of the different dimension attributes for records storedin the chunk. For example, the database system may create larger orsmaller chunks by specifying larger/smaller ranges (or sets of values)for dimension attributes respectively.

In some embodiments, the database system 110 moves existing data undercertain scenarios. For example, the database system may enforce a policythat aligns chunks to specific time intervals. Accordingly, the creationof new chunks at a time based on the time that new locations are addedmay result in violation of such policy. For example, the database systemmay enforce a standard that chunks have a time range of 12 hours.However, if the addition of new locations to the database system occursat 3 hours into a 12-hour time interval, the database system wouldeither not be able to incorporate the new locations for another 9 hours,or would have to maintain some chunks with 3 hours intervals. Thus, incertain scenarios, for example, if the amount of data stored in eachchunk that is currently being populated is below a threshold amount, thedatabase system moves or reallocates existing chunks rather than createnew ones responsive to addition of new location. Accordingly, thedatabase system moves data of the set of chunks being currentlypopulated with records across a new set of chunks distributed across thenew plurality of locations and continues adding records to the new setof chunks.

In another embodiment, the database system delays enforcement of the newpartitioning policy based on the new locations added until the timematches well with chunk alignments. This delayed action can be used bothwhen adding new servers, removing servers in a planned manner, or evenon server crashes (if the system already replicates chunks betweenmultiple servers for high availability). For example, if the systemalready has chunks with time ranges that extend until midnight, and thereconfiguration time is at 11 pm, the database system may not createchunks based on the new partitioning policy for 1 hour (e.g., until arecord is inserted with a time attribute after midnight), but thereconfiguration will have an effect when a new set of chunks is created.In such a scenario, the existing chunks are not reconfigured and onlythe new chunks are allocated over the new set of servers. However, thetime range of the chunks is the same before and after the addition ofthe new locations.

FIG. 8 shows a flowchart illustrating the process of modifying a datapartitioning policy of a database system in response to the addition ofnew locations to the database system, in accordance with an embodiment.The database system 110 includes a plurality of locations, referred toas the first plurality of locations. The database system 110 receives810 requests to insert records in a hypertable. The database systemdistributes the chunks in accordance with a first partitioning policyP1. Accordingly, the database system 110 creates 820 a plurality ofchunks and distributes them across the first plurality of locations. Forexample, if the database system has 5 locations, the database system 110may create 20 chunks and store 4 chunks in each location. The databasesystem 110 distributes the chunks based on dimension attributes of therecords including at least a time attribute. The partitioning policyspecifies various aspects of chunk/creation and distribution includingthe number of chunks that may be created, the configuration of thechunks, and the mapping of the chunks to locations. The database systemmay repeat the steps 810 and 820 multiple times, for example, until thedatabase system 110 is reconfigured to change the number of locations.

The database system 110 receives an indication of the addition of one ormore new locations. For example, a new location may be a storage devicethat is added by a system administrator to an existing server of thedatabase system. Alternatively, a new location may be a new servercomprising one or more storage devices that is added to the databasesystem for storing as well as processing data. As another example, alocation may be storage device of a remote system on which the databasesystem 110 is allowed to store data, for example, a cloud-based storagedevice. The indication of the addition of one or more new locations thatthe database system receives may identify a specific storage device thatis added to the database system or may identify a server that is addedto the database system.

In an embodiment, the database system 110 receives the indication ofaddition of a location by performing a check of all peripheral devicesand servers that can be reached by one or more database system nodes310. In other embodiments, the database system 110 receives theindication by receiving a message from a new location, by a commandexecuted by a database user or administrator. The addition of thelocations to the database system causes the database system 110 to havea second plurality of locations that is more than the number oflocations in the first plurality of locations. The indication ofaddition of the one or more locations is associated with areconfiguration time, for example, the time that the indication isreceived or the time when the addition of the one or more new locationswas completed.

Subsequent to receiving the indication of the addition of one or morenew locations, the database system receives insert requests. Thedatabase system 110 creates 840 a second plurality of chunks, forexample, if the records in the insert requests received cannot beinserted in existing chunks. The database system 110 creates the secondplurality of chunks and assigns them to locations based on a secondpartitioning policy P2. The second partitioning policy P2 maps thesecond plurality of chunks to the second plurality of locations, forexample, as illustrated in FIG. 7(C). The chunks may be uniformlydistributed across the second plurality of locations. Alternatively, thenumber or partition ranges of chunks assigned to the new locations maybe greater than the number or partition ranges of chunks assigned to theexisting locations. For example, more chunks from the second pluralityof chunks may be assigned to the new locations compared to the existinglocations. Alternatively, chunks configured to store more data may beassigned to new locations compared to the existing locations. A chunk C1may be configured to store more data compared to a chunk C2 byspecifying for chunk C1, a set of values for a dimension attribute thathas more elements compared to the set of values for the same dimensionattribute for chunk C2. For example, the time attribute for chunk C1 maybe specified to have a larger time range compared to the time attributefor chunk C2.

The database system 110 subsequently receives 850 requests to insertdata in the database table. The database system 110 stores 860 thereceived records into chunks based on the dimension attributes of therecords. The records may be inserted in chunks created either based onthe first partitioning policy or the second partitioning policy asfurther described herein in connection with FIGS. 9-12. The databasesystem 110 identifies a reconfiguration time T associated with theaddition of the new locations to the database system.

In an embodiment, the database system inserts records into chunks basedon a time attribute of the record. Accordingly, even though a newpartitioning policy is defined, the database system may receive insertrequests and create chunks based on a previous partitioning policy. Forexample, the database system may receive some records very late (i.e.,the time they are received may be significantly after the values of therecords' time attribute), for example, due to delay caused by network orother resources. The database system may create chunks based on an olderpartitioning policy for storing these records. Accordingly, the databasesystem may enforce multiple partitioning policies at the same time,depending on the data of the records that are received and need to beinserted in a hypertable.

FIG. 9 illustrates selection of partitioning policy for creating chunksbased on time attribute of the record, according to an embodiment.Accordingly, independent of the time that the insert request isreceived, if insert requests are received with records having a timeattribute value that is before the reconfiguration time T, any newchunks created for storing the records are created based on the firstpartitioning policy. FIG. 9 shows a timeline 900 and various eventsalong the time line. For example, the database system initially hasthree locations (disks) 910 a, 910 b, and 910 c and creates chunksaccording to partitioning policy P1. At reconfiguration time T, a newlocation 910 d is added to the database system 110. However, if insertrequests received after reconfiguration time T have time attributevalues that are before reconfiguration time T, the database systemcreates chunks for storing the records (if none of the existing chunkscan store the records) according to the first partitioning policy P1.Furthermore, if insert requests received after reconfiguration time Thave time attribute values that are after the reconfiguration time T,the database system creates chunks for storing the records (if none ofthe existing chunks can store the records) according to the secondpartitioning policy P2. Accordingly, the time interval T1 during whichchunks are created according to the first partitioning policy P1 canextend after the reconfiguration time T. Time interval T2 indicates thetime during which chunks are created according to the secondpartitioning policy P2.

FIG. 10 shows a flowchart of the process for selection of partitioningpolicy for creating chunks based on time attribute of the record,according to an embodiment. The database system invokes the procedureshown in FIG. 10 if the database system determines for a record beinginserted that the record cannot be stored in any existing chunk and anew chunk needs to be created. The database system 110 determines 1010the value of the time attribute of a record received for inserting inthe database table. The database system 110 compares 1020 the value ofthe time attribute of the record with the reconfiguration time T. If thedatabase system 110 determines that the time attribute of the record isless than the reconfiguration time T, the database system 110 creates achunk 1030 based on the first partitioning policy P1. If the databasesystem 110 determines that the time attribute of the record is greaterthan (or equal to) the reconfiguration time T, the database system 110creates 1040 a chunk based on the second partitioning policy P2. Therecord is stored 1050 in the chunk that is created.

FIG. 11 illustrates selection of partitioning policy for creating chunksbased on time of receipt of a record by the database system, accordingto an embodiment. FIG. 11 shows a timeline 1100 and various events alongthe time line. For example, the database system initially has threelocations (disks) 1110 a, 1110 b, and 1110 c and creates chunksaccording to partitioning policy P1. At reconfiguration time T, a newlocation 1110 d is added to the database system 110. The database systemselects the partitioning policy for creating chunks based on the time ofarrival of the insert request (assuming no existing chunks can be usedfor storing records that are received for inserting in the hypertable).Accordingly, after reconfiguration time T (i.e., during time intervalT2), chunks are created according to the second partitioning policy P2whereas before reconfiguration time T (i.e., during time interval T1),chunks are created according to the first partitioning policy P1.Accordingly, the partitioning policy selected for creating chunks isselected independently of the value of the time attribute of the recordsbeing inserted. For example, if for any reason records having timeattribute values that correspond to time occurring beforereconfiguration time T arrive late, i.e., after reconfiguration time T,the database system creates chunks according to the second partitioningpolicy P2 for storing the records. Accordingly, records with timeattribute value less than reconfiguration time T can be stored in chunkscreated according to either partitioning policy P1 or P2.

In some embodiments, the database system continues to insert recordsinto a chunk that was created before reconfiguration time T even if theinsert request arrives after reconfiguration time T so long as the timeattribute of the record corresponds to the time range for the chunk. Inother embodiments, the database system modifies an existing chunk thatwas created according to the first partitioning policy P1 so as toreduce the time range (if necessary) to correspond to the latest recordinserted into the chunk. For example, if the insert request's arrivaltime is 5:30 am and the chunk's current time range is until noon, thedatabase system identifies the record with the highest value for itstime attribute in that chunk. Assuming that the record with the highesttime value in that chunk has a time of 5:45 am, the database systemmodifies the end of the chunk's time range to a time greater than orequal to 5:45 am, for example, 6 am. Subsequently, if the databasesystem receives a record at time greater than 6 am, the database systemcreates a new chunk according to the new partitioning policy P2 startingat 6 am.

In some embodiments, the database system may create overlapping chunksas a result of reconfiguration of the system. The database systemenforces a policy that after reconfiguration of the system, the databasesystem does not insert records in chunks created based on the firstpartitioning policy P1. As a result, after reconfiguration of thesystem, the database system creates a new chunk for storing a recordbased on partitioning policy P2, even if there is an existing chunkcreated based on policy P1 that maps to the dimension attributes of therecord. As a result, a record having a particular dimension attributecould potentially be stored in a chunk C1 created based on the firstpartitioning policy P1 or in a chunk C2 created based on the secondpartitioning policy P2. As a result, chunks C1 and C2 are overlappingsuch that a record could map to both chunks C1 and C2, If the databasesystem subsequently receives queries that process a particular record R,the database system 110 determines whether the record R was stored in achunk created based on the first partitioning policy P1 or the secondpartitioning policy P2. Accordingly, the database system 110 may have tocheck two possible chunks to determine where the record R is stored.

In some embodiments, the database system 110 creates the new chunks thatoverlap old chunks in terms of the time range used for partitioning therecords. As a result, even after creation of a new set of chunksresponsive to the addition of new locations, the database system mayinsert records into old chunks that were created before the addition ofthe locations. While this may involve the old chunks (from the old view)continuing to see some fraction of new inserts—although this can bemitigated based on the insert policy for overlapping chunks, e.g., onesuch policy prefers inserting new records to the smaller-sizedchunk—this overlap will not continue into future intervals. For example,continuing with the above example, when the database system creates thenew chunks 9 hours into the existing chunks' interval, it sets the startand end times for the new chunks to be the same as the existing chunks(i.e., 9 hours ago and 3 hours hence). But, because the database systemcan employ a policy to write to smaller-sized chunks, for example,inserts will be made to the new chunks rather than the existing ones,even though the two sets have overlapping time periods.

In embodiments of the database system that use a purely size-basedapproach to determining when to close a chunk, these time intervalissues do not arise, and the database system then simply closes theexisting chunks (even when their size at the time of systemreconfiguration may be smaller than the standard threshold size) andcreates new ones using the new partitioning policy.

Because the new view may maintain a different set of partitions, thedatabase system may maintain additional metadata that associates each ofthese reconfigurations into an “epoch.” In particular, each epoch may beassociated with various information, including a time period, the set ofpartitions, and a system view. Then, as described above, in order todetermine a hypertable's partitions at a particular time, the databasesystem might need to first determine the epoch associated with the time,then determine the partitions associated with this epoch. This processis described above in the context of an insert method that the databasesystem employs.

Architecture of Computer for a Database System

FIG. 12 is a high-level block diagram illustrating an example of acomputer 1200 for use as one or more of the entities illustrated in FIG.1, according to one embodiment. Illustrated are at least one processor1202 coupled to a memory controller hub 1220, which is also coupled toan input/output (I/O) controller hub 1222. A memory 1206 and a graphicsadapter 1212 are coupled to the memory controller hub 1222, and adisplay device 1218 is coupled to the graphics adapter 1212. A storagedevice 1208, keyboard 1210, pointing device 1214, and network adapter1216 are coupled to the I/O controller hub. The storage device mayrepresent a network-attached disk, local and remote RAID, or a SAN(storage area network). A storage device 1208, keyboard 1210, pointingdevice 1214, and network adapter 1216 are coupled to the I/O controllerhub 1222. Other embodiments of the computer 1200 have differentarchitectures. For example, the memory is directly coupled to theprocessor in some embodiments, and there are multiple different levelsof memory coupled to different components in other embodiments. Someembodiments also include multiple processors that are coupled to eachother or via a memory controller hub.

The storage device 1208 includes one or more non-transitorycomputer-readable storage media such as one or more hard drives, compactdisk read-only memory (CD-ROM), DVD, or one or more solid-state memorydevices. The memory holds instructions and data used by the processor1202. The pointing device 1214 is used in combination with the keyboardto input data into the computer 1200. The graphics adapter 1212 displaysimages and other information on the display device 1218. In someembodiments, the display device includes a touch screen capability forreceiving user input and selections. One or more network adapters 1216couple the computer 1200 to a network. Some embodiments of the computerhave different and/or other components than those shown in FIG. 12. Forexample, the database system can be comprised of one or more serversthat lack a display device, keyboard, pointing device, and othercomponents, while a client device acting as a requester can be a server,a workstation, a notebook or desktop computer, a tablet computer, anembedded device, or a handheld device or mobile phone, or another typeof computing device. The requester to the database system also can beanother process or program on the same computer on which the databasesystem operates.

The computer 1200 is adapted to execute computer program modules forproviding functionality described herein. As used herein, the term“module” refers to computer program instructions and/or other logic usedto provide the specified functionality. Thus, a module can beimplemented in hardware, firmware, and/or software. In one embodiment,program modules formed of executable computer program instructions arestored on the storage device, loaded into the memory, and executed bythe processor.

Additional Considerations

In time-series workloads, writes are typically made to recent timeintervals, rather than distributed across many old ones. This allows thedatabase system 110 to efficiently write batch inserts to a small numberof tables as opposed to performing many small writes across one gianttable. Further, the database systems' clustered architecture also takesadvantage of time-series workloads to recent time intervals, in order toparallelize writes across many servers and/or disks to further supporthigh data ingest rates. These approaches improve performance whenemployed on various storage technologies, including in-memory storage,hard drives (HDDs), or solid-state drives (SSDs).

Because chunks are right-sized to servers, and thus the database systemdoes not build massive single tables, the database system avoids orreduces swapping its indexes to disks for recent time intervals (wheremost writes typically occur). This occurs because the database systemmaintains indexes local to each chunk; when inserting new records into achunk, only that chunks' (smaller) indexes need to be updated, ratherthan a giant index built across all the hypertable's data. Thus, forchunks associated with recent time intervals that are regularlyaccessed, particularly if the chunks are sized purposefully, the chunks'indexes can be maintained in memory. Yet the database system can stillefficiently support many different types of indexes on different typesof columns (e.g., based on what is supported by each node's databaseengine, such as PostgreSQL), including B-tree, B+-tree, GIN, GiST,SP-GiST, BRIN, Hash, LSM Tree, fractal trees, and other types ofindexes.

The database system combines the transparent partitioning of itshypertable abstraction with a number of query optimizations. Theseoptimizations include those which serve to minimize the number and setof chunks that must be contacted to satisfy a query, to reduce theamount of records that are transferred back from a query that touches achunk, to specify whether raw records or aggregates results aretransferred back from a chunk, and so forth.

Common queries to time-series data include (i) slicing across time for agiven object (e.g., device id), slicing across many objects for a giventime interval, or (iii) querying the last reported data records across(a subset of) all objects or some other distinct object label. Whileusers perform these queries as if interacting with a single hypertable,the database system leverages internally-managed metadata to only querythose chunks that may possibly satisfy the query predicate. Byaggressively pruning many chunks and servers to contact in its queryplan—or during execution, when the system may have additionalinformation—the database system improves both query latency andthroughput.

Similarly, for items like unique devices, users, or locations, thedatabase system may receive queries like “select the last K readings forevery device.” While this query can be natively expressed in SQL using a“SELECT DISTINCT” query (for finding the first or last single value perdistinct item) or via windowing functions (for finding K such values),such a query can turn into a full table scan in many relationaldatabases. In fact, this full table scan could continue back to thebeginning of time to capture “for every device”, or otherwise eithersacrifice completeness with some arbitrarily-specified time range orinvolve a large WHERE clause or JOIN against some set of devices ofinterest (which may be maintained in a manual or automated fashion).

In some embodiments, the database system maintains additional metadataabout a hypertable's fields in order to optimize such queries. Forexample, the database system records information about every distinct(different) value for that field in the database (e.g., the latest row,chunk, or time interval to which it belongs). The database system usesthis metadata along with its other optimizations, so that such queriesfor distinct items avoid touching unnecessary chunks, and performefficiently-indexed queries on each individual chunk. The decision tomaintain such metadata might be made manually or via automated means fora variety of reasons, including based on a field's type, the cardinalityof the field's distinct items, query and workload patterns, and soforth.

The database system may perform other query optimizations that benefitboth single-node and clustered deployments. When joining data frommultiple tables (either locally or across the network, e.g., via foreigndata wrappers), traditional databases may first select all data matchingthe query predicate, optionally ORDER the data, then perform therequested LIMIT. Instead, the database system 110 first performs thequery and post-processing (e.g., ORDER and LIMIT) on each chunk, andonly then merges the resulting set from each chunk (after which itperforms a final ordering and limit).

The database system 110 uses LIMIT pushdown for non-aggregate queries tominimize copying data across the network or reading unnecessary datafrom tables. The database system also pushes down aggregations for manycommon functions (e.g., SUM, AVG, MIN, MAX, COUNT) to the servers onwhich the chunks reside. Primarily a benefit for clustered deployments,this distributed query optimization greatly minimizes network transfersby performing large rollups or GROUP_BYs in situ on the chunks' servers,so that only the computed results need to be joined towards the end ofthe query, rather than raw data from each chunk. In particular, eachnode in the database system performs its own partial aggregation, andthen only return that result to the requesting node.

For example, if the query to the database system requests some MAX(maximum value), then the first node processing the hypertable querysends MAX queries to other nodes; each receiving node performs the MAXon its own local chunks before sending the result back to the firstnode. This first node computes the MAX of these local maximum values,and returns this result. Similarly, if the hypertable query asks for theAVG (average), then the first node sends queries to other servers thatask for the sum and count of some set of rows. These nodes can returntheir sums and counts to the first node, which then computes the totalaverage from these values (by dividing the sum of sums by the sum ofcounts).

The database system computes joins between hypertables and standardrelational tables. These standard tables can be stored either directlyin the database system or accessed from external databases, e.g., viaforeign data wrappers.

The database system 110 performs joins between two hypertables,including in a number of ways involving distributed optimizations, e.g.,distributed joins. Such optimizations include those using hash-basedpartitioning, as well as those that carefully minimize data copying byonly sending data from one hypertable's chunks to the servers with theother's chunks according to the join being performed, optionallyleveraging the metadata associated with the chunk. Such optimizationsalso include placing the chunks of hypertables that will be regularlyjoined on servers in a way that like keys or key ranges are commonlycollocated on the same server, to minimize sending data over the networkduring joins.

The database system allows for easily defining data retention policiesbased on time. For example, administrators or users can use explicitcommands or configure the system to cleanup/erase data more than X weeksold. The system's chunking also helps make such retention policies moreefficient, as the database system then just drops entire chunks(internal data tables) that are expired, as opposed to needing to deleteindividual rows and aggressively vacuum the resulting tables, althoughthe database system does support such row-based deletions.

For efficiency, the database system enforces such data retentionpolicies lazily. That is, individual records that are older than theexpiry period might not be immediately deleted, depending upon policy orconfiguration. Rather, when all data in a chunk becomes expired, thenthe entire chunk is dropped. Alternatively, the database system uses ahybrid of dropping chunks and deleting individual rows when performingdata deletions or adhering to data retention policies.

The foregoing description of the embodiments of the invention has beenpresented for the purpose of illustration; it is not intended to beexhaustive or to limit the invention to the precise forms disclosed.Persons skilled in the relevant art can appreciate that manymodifications and variations are possible in light of the abovedisclosure.

Some portions of this description describe the embodiments of theinvention in terms of algorithms and symbolic representations ofoperations on information. These algorithmic descriptions andrepresentations are commonly used by those skilled in the dataprocessing arts to convey the substance of their work effectively toothers skilled in the art. These operations, while describedfunctionally, computationally, or logically, are understood to beimplemented by computer programs or equivalent electrical circuits,microcode, or the like. Furthermore, it has also proven convenient attimes, to refer to these arrangements of operations as modules, withoutloss of generality. The described operations and their associatedmodules may be embodied in software, firmware, hardware, or anycombinations thereof.

Any of the steps, operations, or processes described herein may beperformed or implemented with one or more hardware or software modules,alone or in combination with other devices. In one embodiment, asoftware module is implemented with a computer program productcomprising a computer-readable medium containing computer program code,which can be executed by a computer processor for performing any or allof the steps, operations, or processes described.

Embodiments of the invention may also relate to an apparatus forperforming the operations herein. This apparatus may be speciallyconstructed for the required purposes, and/or it may comprise ageneral-purpose computing device selectively activated or reconfiguredby a computer program stored in the computer. Such a computer programmay be stored in a tangible computer readable storage medium or any typeof media suitable for storing electronic instructions, and coupled to acomputer system bus. Furthermore, any computing systems referred to inthe specification may include a single processor or may be architecturesemploying multiple processor designs for increased computing capability.

Finally, the language used in the specification has been principallyselected for readability and instructional purposes, and it may not havebeen selected to delineate or circumscribe the inventive subject matter.It is therefore intended that the scope of the invention be limited notby this detailed description, but rather by any claims that issue on anapplication based hereon. Accordingly, the disclosure of the embodimentsof the invention is intended to be illustrative, but not limiting, ofthe scope of the invention.

What is claimed is:
 1. A computer-implemented method comprising:receiving, by a database system, an insert request, the insert requestidentifying a hypertable and one or more input records for inserting inthe hypertable, each record having a plurality of attributes including aset of dimension attributes, the set of dimension attributes including atime attribute, wherein the hypertable represents a database tablepartitioned into a plurality of chunks along the set of dimensionattributes, each chunk associated with a set of values corresponding toeach dimension attribute, such that, for each record stored in thechunk, and for each dimension attribute of the record, the value of thedimension attribute of the record maps to a value from the set of valuesfor that dimension attribute as specified by the chunk; for each of theone or more input records, determining whether the input record shouldbe stored in a new chunk to be created, the determining based on thevalues of dimension attributes of the input record; responsive todetermining that an input record should be stored in a new chunk to becreated, determining sets of values corresponding to each dimensionattribute for the new chunk to be created; dynamically creating a newchunk for storing the input record, the new chunk associated with thedetermined sets of values corresponding to each dimension attribute;updating the hypertable by storing the input record in the new chunk;and processing the data stored in the updated hypertable in response toone or more subsequent queries identifying the hypertable.
 2. Thecomputer-implemented method of claim 1, wherein the database systemstores data on a set of one or more servers, wherein the plurality ofchunks are distributed across one or more locations, wherein eachlocation corresponds to one of: a storage device added to a server fromthe set of servers used by the database system; a storage devicebelonging to a new server, wherein the new server is added to the set ofservers used by the database system; or a network attached storagedevice of a remote server made accessible to a server from the set ofservers used by the database system.
 3. The computer-implemented methodof claim 1, wherein determining that the input record should be storedin a new chunk is responsive to determining that the input record cannotbe stored in any existing chunk of the hypertable.
 4. Thecomputer-implemented method of claim 1, wherein determining sets ofvalues corresponding to each dimension attribute for the new chunkcomprises: determining a size of one or more recently created chunks;predicting a size of the new chunk based on the size of the recentlycreated chunks; and determining a set of values corresponding to adimension attribute for the new chunk based on one or more factors, thefactors including the predicted size of the new chunk.
 5. Thecomputer-implemented method of claim 1, wherein determining sets ofvalues corresponding to each dimension attribute for the new chunkcomprises: determining that a size of one or more recently createdchunks exceeds a threshold value; and wherein, responsive to determiningthat the size of the recently created chunks exceeds the thresholdvalue, determining the set of values corresponding to a dimensionattribute to have fewer elements than the set of values corresponding tothe dimension attribute of the recently created chunks.
 6. Thecomputer-implemented method of claim 1, wherein determining sets ofvalues corresponding to each dimension attribute for the new chunkcomprises: monitoring a performance of one or more existing chunks; anddetermining the set of values corresponding to a dimension attribute forthe new chunk based on the monitored performance.
 7. Thecomputer-implemented method of claim 1, wherein determining sets ofvalues corresponding to each dimension attribute for the new chunkcomprises: identifying a storage medium for storing the new chunk;accessing properties of the storage medium, the properties describing arate of access of data stored on the storage medium; and determining aset of values corresponding to a dimension attribute for the new chunkbased on the properties of the storage medium.
 8. Thecomputer-implemented method of claim 1, wherein the set of dimensionattributes includes a second attribute of the record, wherein the secondattribute of the record describes an identifier for an entity associatedwith the record.
 9. The computer-implemented method of claim 1, whereinthe hypertable is associated with one or more indexes, the methodfurther comprising, creating the one or more indexes for the new chunk.10. The computer-implemented method of claim 1, wherein processing thedata stored in the updated hypertable in response to one or moresubsequent database queries identifying the hypertable comprises:receiving a database query for processing data stored in the hypertable;identifying a plurality of chunks of the hypertable, each of theplurality of chunks storing data likely to be processed by the databasequery; identifying one or more locations storing the plurality ofchunks, each of the one or more locations comprising a storage devicestoring one or more chunks of the hypertable; for each of the one ormore locations, determining a partial result for the database querybased on the data stored in the location; aggregating partial resultscorresponding to each of the one or more locations to determine theresult of execution of the database query; and sending the result ofexecution of the database query.
 11. The computer-implemented method ofclaim 1, further comprising replicating a chunk of the hypertable acrossa plurality of locations, wherein replicating the chunk comprisesinserting a record into two or more replicas of each chunk, wherein eachreplica is stored at a different location from the plurality oflocations.
 12. The computer-implemented method of claim 11, whereinreplicating the chunk further comprises: determining a number ofreplicas of the chunk based on an age of the chunk, wherein a greaternumber of replicas is maintained for a first chunk than for a secondchunk if the age value of the first chunk is less than the age value ofthe second chunk.
 13. The computer-implemented method of claim 11,wherein replicating chunks of the hypertable further comprises:determining a type of storage device used for storing replicas of eachchunk based on an age of the chunk.
 14. The computer-implemented methodof claim 1, wherein each location is associated with a type and thehypertable is associated with a threshold age value, further comprising:identifying a chunk of the hypertable having an age value greater thanthe threshold age value of the hypertable; and moving the identifiedchunk from a first location having a first type to a second locationhaving a second type.
 15. A non-transitory computer readable storagemedium storing instructions for: receiving, by a database system, aninsert request, the insert request identifying a hypertable and one ormore input records for inserting in the hypertable, each record having aplurality of attributes including a set of dimension attributes, the setof dimension attributes including a time attribute, wherein thehypertable represents a database table partitioned into a plurality ofchunks along the set of dimension attributes, each chunk associated witha set of values corresponding to each dimension attribute, such that,for each record stored in the chunk, and for each dimension attribute ofthe record, the value of the dimension attribute of the record maps to avalue from the set of values for that dimension attribute as specifiedby the chunk; for each of the one or more input records, determiningwhether the input record should be stored in a new chunk to be created,the determining based on the values of dimension attributes of the inputrecord; responsive to determining that an input record should be storedin a new chunk to be created, determining sets of values correspondingto each dimension attribute for the new chunk to be created; dynamicallycreating a new chunk for storing the input record, the new chunkassociated with the determined sets of values corresponding to eachdimension attribute; updating the hypertable by storing the input recordin the new chunk; and processing the data stored in the updatedhypertable in response to one or more subsequent queries identifying thehypertable.
 16. The non-transitory computer readable storage medium ofclaim 15, wherein the database system stores data on a set of one ormore servers, wherein the plurality of chunks are distributed across oneor more locations, and wherein each location corresponds to one of: astorage device added to a server from the set of servers used by thedatabase system; a storage device belonging to a new server, wherein thenew server is added to the set of servers used by the database system;or a network attached storage device of a remote server made accessibleto a server from the set of servers used by the database system.
 17. Thenon-transitory computer readable storage medium of claim 15, whereininstructions for determining sets of values corresponding to eachdimension attribute for the new chunk comprise instructions for:determining a size of one or more recently created chunks; predicting asize of the new chunk based on the size of the recently created chunks;and determining a set of values corresponding to a dimension attributefor the new chunk based on one or more factors, the factors includingthe predicted size of the new chunk.
 18. The non-transitory computerreadable storage medium of claim 15, wherein instructions fordetermining sets of values corresponding to each dimension attribute forthe new chunk comprise instructions for: determining that a size of oneor more recently created chunks exceeds a threshold value; and wherein,responsive to determining that the size of the recently created chunksexceeds the threshold value, determining the set of values correspondingto a dimension attribute to have fewer elements than the set of valuescorresponding to the dimension attribute of the recently created chunks.19. The non-transitory computer readable storage medium of claim 15,wherein instructions for determining sets of values corresponding toeach dimension attribute for the new chunk comprise instructions for:monitoring a performance of one or more existing chunks; and determiningthe set of values corresponding to a dimension attribute for the newchunk based on the monitored performance.
 20. The non-transitorycomputer readable storage medium of claim 15, wherein instructions fordetermining sets of values corresponding to each dimension attribute forthe new chunk comprise instructions for: identifying a storage mediumfor storing the new chunk; accessing properties of the storage medium,the properties describing a rate of access of data stored on the storagemedium; and determining a set of values corresponding to a dimensionattribute for the new chunk based on the properties of the storagemedium.
 21. The non-transitory computer readable storage medium of claim15, wherein instructions for processing the data stored in the updatedhypertable in response to one or more subsequent database queriesidentifying the hypertable comprise instructions for: receiving adatabase query for processing data stored in the hypertable; identifyinga plurality of chunks of the hypertable, each of the plurality of chunksstoring data likely to be processed by the database query; identifyingone or more locations storing the plurality of chunks, each of the oneor more locations comprising a storage device storing one or more chunksof the hypertable; for each of the one or more locations, determining apartial result for the database query based on the data stored in thelocation; aggregating partial results corresponding to each of the oneor more locations to determine the result of execution of the databasequery; and sending the result of execution of the database query.
 22. Acomputer system comprising: one or more processors; and a non-transitorycomputer readable storage medium storing instructions for execution bythe one or more processors, the instructions for: receiving, by adatabase system, an insert request, the insert request identifying ahypertable and one or more input records for inserting in thehypertable, each record having a plurality of attributes including a setof dimension attributes, the set of dimension attributes including atime attribute, wherein the hypertable represents a database tablepartitioned into a plurality of chunks along the set of dimensionattributes, each chunk associated with a set of values corresponding toeach dimension attribute, such that, for each record stored in thechunk, and for each dimension attribute of the record, the value of thedimension attribute of the record maps to a value from the set of valuesfor that dimension attribute as specified by the chunk; for each of theone or more input records, determining whether the input record shouldbe stored in a new chunk to be created, the determining based on thevalues of dimension attributes of the input record; responsive todetermining that an input record should be stored in a new chunk to becreated, determining sets of values corresponding to each dimensionattribute for the new chunk to be created; dynamically creating a newchunk for storing the input record, the new chunk associated with thedetermined sets of values corresponding to each dimension attribute;updating the hypertable by storing the input record in the new chunk;and processing the data stored in the updated hypertable in response toone or more subsequent queries identifying the hypertable.
 23. Thecomputer system of claim 22, wherein the database system stores data ona set of one or more servers, wherein the plurality of chunks aredistributed across one or more locations, and wherein each locationcorresponds to one of: a storage device added to a server from the setof servers used by the database system; a storage device belonging to anew server, wherein the new server is added to the set of servers usedby the database system; or a network attached storage device of a remoteserver made accessible to a server from the set of servers used by thedatabase system.
 24. The computer system of claim 22, whereininstructions for determining sets of values corresponding to eachdimension attribute for the new chunk comprise instructions for:determining a size of one or more recently created chunks; predicting asize of the new chunk based on the size of the recently created chunks;and determining a set of values corresponding to a dimension attributefor the new chunk based on one or more factors, the factors includingthe predicted size of the new chunk.
 25. The computer system of claim22, wherein instructions for determining sets of values corresponding toeach dimension attribute for the new chunk comprise instructions for:determining that a size of one or more recently created chunks exceeds athreshold value; and wherein, responsive to determining that the size ofthe recently created chunks exceeds the threshold value, determining theset of values corresponding to a dimension attribute to have fewerelements than the set of values corresponding to the dimension attributeof the recently created chunks.
 26. The computer system of claim 22,wherein instructions for determining sets of values corresponding toeach dimension attribute for the new chunk comprise instructions for:monitoring a performance of one or more existing chunks; and determiningthe set of values corresponding to a dimension attribute for the newchunk based on the monitored performance.
 27. The computer system ofclaim 22, wherein instructions for determining sets of valuescorresponding to each dimension attribute for the new chunk compriseinstructions for: identifying a storage medium for storing the newchunk; accessing properties of the storage medium, the propertiesdescribing a rate of access of data stored on the storage medium; anddetermining a set of values corresponding to a dimension attribute forthe new chunk based on the properties of the storage medium.
 28. Thecomputer system of claim 22, wherein instructions for processing thedata stored in the updated hypertable in response to one or moresubsequent database queries identifying the hypertable compriseinstructions for: receiving a database query for processing data storedin the hypertable; identifying a plurality of chunks of the hypertable,each of the plurality of chunks storing data likely to be processed bythe database query; identifying one or more locations storing theplurality of chunks, each of the one or more locations comprising astorage device storing one or more chunks of the hypertable; for each ofthe one or more locations, determining a partial result for the databasequery based on the data stored in the location; aggregating partialresults corresponding to each of the one or more locations to determinethe result of execution of the database query; and sending the result ofexecution of the database query.